(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.jibo = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Orchestrator = require("orchestrator");
const ServiceClients = require("jibo-service-clients");
const jibo_loader_1 = require("jibo-loader");
const GlobalPerfTimer_1 = require("./utils/perf/GlobalPerfTimer");
const SerialTimer_1 = require("./utils/perf/SerialTimer");
const mim_1 = require("./bt/mim");
const Analytics_1 = require("./bt/mim/analytics/Analytics");
const electron_1 = require("./utils/electron");
const jibo_kb_1 = require("jibo-kb");
const RemoteService_1 = require("./services/remote/RemoteService");
const log_1 = require("./log");
const RunMode = {
    SIMULATOR: "SIMULATOR",
    REMOTELY: "REMOTELY",
    ON_ROBOT: "ON_ROBOT",
    UNIT_TESTS: "UNIT_TESTS"
};
class Runtime {
    constructor(classes) {
        if (Runtime._instance) {
            throw new Error("Jibo Singleton may only be initialized once.");
        }
        Runtime._instance = this;
        this.utils = classes.utils;
        this.services = classes.services;
        this.RunMode = RunMode;
        this.system = ServiceClients.system;
        this.kb = new jibo_kb_1.KnowledgeBase();
        this.lps = ServiceClients.lps;
        this.ics = ServiceClients.ics;
        this.tts = ServiceClients.tts;
        this.timer = new classes.utils.Timer();
        this.log = log_1.default;
        this.performance = ServiceClients.performance;
        this.analytics = new Analytics_1.default();
        this.wifi = ServiceClients.wifi;
        this.errors = ServiceClients.errors;
        this.secureTransferService = ServiceClients.secureTransferService;
        this.web = ServiceClients.web;
        this.scheduler = ServiceClients.scheduler;
        this.globalEvents = new classes.services.GlobalEvents();
        this.remote = new RemoteService_1.default();
        if (electron_1.default) {
            this.bt = new classes.bt.Factory(classes.bt);
            this.flow = new classes.flow.FlowExecutorFactory(classes.flow);
            PIXI.utils.skipHello();
            this.face = new classes.rendering.FaceRenderer(this.timer);
            this.rendering = classes.rendering;
            this.behaviorEmitter = new classes.bt.BehaviorEmitter();
        }
        this.session = new classes.services.SessionManager();
        this.systemManager = ServiceClients.systemManager;
        this.options = null;
        this._installPlugins();
        this.mim = mim_1.MimManager.instance;
    }
    static registerPlugin(pluginClass, id, options) {
        options = Object.assign({
            depends: [],
            api: false,
            name: id,
            electron: false
        }, options || {});
        const plugin = {
            pluginClass,
            id,
            name: options.name,
            api: options.api,
            depends: options.depends,
            electron: options.electron,
            installed: false,
            initialized: false
        };
        Runtime._plugins.push(plugin);
        return plugin;
    }
    init(options, callback) {
        if (Runtime.isInitializing || Runtime.isInitialized) {
            throw new Error('Jibo may only be initialized once.');
        }
        this.initTimer = new SerialTimer_1.default("initNetworkServices", GlobalPerfTimer_1.default.get());
        if (typeof options === 'function') {
            callback = options;
            options = null;
        }
        else if (typeof options === 'string' || options instanceof HTMLElement) {
            options = { display: options };
        }
        this.options = Object.assign({
            display: null
        }, options || {});
        if (typeof callback === 'function') {
            this._init((err) => {
                this.initTimer.stop();
                if (electron_1.default) {
                    Runtime.ipcRenderer.send('init-done');
                }
                callback(err);
            });
        }
    }
    get runMode() {
        let runMode = process.env.runMode || process.env.RUNMODE;
        if (!runMode && process.platform === 'linux' && process.arch === 'arm') {
            runMode = RunMode.ON_ROBOT;
        }
        return runMode;
    }
    get plugins() {
        return Runtime._plugins;
    }
    _init(callback) {
        Runtime.isInitializing = true;
        if (electron_1.default) {
            Runtime.ipcRenderer.send('get-context');
        }
        this._initPlugins((err) => {
            GlobalPerfTimer_1.default.get().stop();
            if (err) {
                console.error(err);
            }
            else {
                if (this.options.analytics) {
                    this.analytics = this.options.analytics;
                }
                if (electron_1.default) {
                    let display = this.options.display;
                    if (display) {
                        if (typeof display === "string") {
                            display = document.getElementById(display);
                        }
                        if (!display) {
                            throw new Error("Display canvas element is invalid");
                        }
                        Runtime.instance.face.init(display);
                    }
                }
                Runtime.isInitialized = true;
                this.timer.start();
            }
            callback(err);
        });
    }
    _installPlugins() {
        const orc = new Orchestrator();
        const plugins = [];
        Runtime._plugins.forEach((plugin) => {
            if (plugin.installed || (plugin.electron && !electron_1.default)) {
                return;
            }
            plugins.push(plugin.id);
            orc.add(plugin.id, plugin.depends, (done) => {
                plugin.installed = true;
                plugin.instance = new plugin.pluginClass();
                if (plugin.api) {
                    this[plugin.name] = plugin.instance.api || plugin.instance;
                }
                done();
            });
        });
        if (plugins.length) {
            orc.add('end', plugins, (done) => {
                done();
            });
            orc.start('end');
        }
    }
    _initPlugins(done) {
        const orc = new Orchestrator();
        const plugins = [];
        Runtime._plugins.forEach((plugin) => {
            if (plugin.initialized || (plugin.electron && !electron_1.default)) {
                return;
            }
            plugins.push(plugin.id);
            orc.add(plugin.id, plugin.depends, (callback) => {
                let startTime = Date.now();
                this.log.info(`Starting to initialize plugin '${plugin.id}'`);
                plugin.instance.init((err, api) => {
                    this.log.info(`done initializing ${plugin.id} in ${Date.now() - startTime} ms`);
                    plugin.initialized = true;
                    if (api) {
                        this[plugin.name] = api;
                    }
                    callback(err);
                });
            });
        });
        if (!plugins.length) {
            return done();
        }
        orc.add('end', plugins, (done) => {
            done();
        });
        orc.start('end', (error) => {
            if (error) {
                console.error('Error: ' + error);
                done(error);
            }
            else {
                done();
            }
        });
    }
    static get instance() {
        return Runtime._instance;
    }
    static get ipcRenderer() {
        if (!Runtime._ipcRenderer && electron_1.default) {
            Runtime._ipcRenderer = require('electron').ipcRenderer;
        }
        return Runtime._ipcRenderer;
    }
}
Runtime.isInitializing = false;
Runtime.isInitialized = false;
Runtime.electron = electron_1.default;
Runtime._ipcRenderer = null;
Runtime._plugins = [];
Runtime.registerPlugin(jibo_loader_1.LoaderPlugin, 'loader', {
    api: true
});
exports.default = Runtime;

},{"./bt/mim":63,"./bt/mim/analytics/Analytics":57,"./log":75,"./services/remote/RemoteService":190,"./utils/electron":205,"./utils/perf/GlobalPerfTimer":209,"./utils/perf/SerialTimer":212,"electron":undefined,"jibo-kb":undefined,"jibo-loader":undefined,"jibo-service-clients":undefined,"orchestrator":undefined}],2:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Status_1 = require("./Status");
class BaseElement {
    constructor(options, defaultOptions) {
        this._currentStatus = Status_1.default.INVALID;
        options = options || {};
        defaultOptions = defaultOptions || {};
        this.options = Object.assign({
            name: "",
            emitter: null,
            blackboard: null,
            assetPack: ""
        }, defaultOptions, options);
        this._currentStatus = Status_1.default.INVALID;
        this.blackboard = this.options.blackboard;
        this.emitter = this.options.emitter;
        this.assetPack = this.options.assetPack || "";
    }
    get name() {
        return this.options.name;
    }
    get currentStatus() {
        return this._currentStatus;
    }
    stop() {
        return Promise.resolve();
    }
    destroy() {
        this.options = null;
        this.blackboard = null;
        this.emitter = null;
        this.assetPack = null;
        this._currentStatus = null;
    }
    stopAndDestroy() {
        return this.stop().catch(() => { }).then(() => {
            this.destroy();
        });
    }
}
exports.default = BaseElement;

},{"./Status":10}],3:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Status_1 = require("./Status");
const BaseElement_1 = require("./BaseElement");
class Behavior extends BaseElement_1.default {
    constructor(options, defaultOptions = {}) {
        super(options, Object.assign({
            decorators: []
        }, defaultOptions || {}));
        this.decorators = this.options.decorators;
        this.parent = null;
        this.waitDecorators = [];
        this.waitDecoratorsLength = 0;
    }
    destroy() {
        if (this._decorators) {
            this._decorators.forEach((decorator) => {
                decorator.destroy();
            });
        }
        this.parent = null;
        this._decorators = null;
        this.waitDecorators = null;
        super.destroy();
    }
    get decorators() { return this._decorators; }
    set decorators(decorators) {
        this._decorators = decorators;
        if (decorators) {
            decorators.forEach((decorator) => {
                decorator.behavior = this;
            });
        }
    }
    start() {
        return true;
    }
    _pause() {
        this.previousStatus = this._currentStatus;
        this._currentStatus = Status_1.default.PAUSED;
    }
    _unpause() {
        this._currentStatus = this.previousStatus;
    }
    _start() {
        if (this._currentStatus === Status_1.default.IN_PROGRESS) {
            return false;
        }
        this.waitDecorators.length = this.waitDecoratorsLength = 0;
        if (this._decorators.length) {
            for (let i = 0; i < this._decorators.length; i++) {
                let success = this._decorators[i]._start();
                if (success === Status_1.default.WAIT) {
                    this.waitDecorators.push(this._decorators[i]);
                    this.waitDecoratorsLength++;
                }
                else if (!success) {
                    this._currentStatus = Status_1.default.FAILED;
                    this._stop();
                    return false;
                }
            }
        }
        if (this.waitDecorators.length === 0) {
            let success = this.start();
            this._currentStatus = success ? Status_1.default.IN_PROGRESS : Status_1.default.FAILED;
            if (!success) {
                this._stop();
            }
            return success;
        }
        else {
            this._currentStatus = Status_1.default.IN_PROGRESS;
            return true;
        }
    }
    _stop() {
        const promises = [];
        if (this._decorators.length) {
            this._decorators.forEach(function (decorator) {
                if (decorator.currentStatus === Status_1.default.IN_PROGRESS) {
                    promises.push(decorator._stop());
                }
            });
        }
        if (this._currentStatus === Status_1.default.IN_PROGRESS) {
            this._currentStatus = Status_1.default.INTERRUPTED;
            promises.push(this.stop());
        }
        if (promises.length === 0) {
            return Promise.resolve();
        }
        else if (promises.length === 1) {
            return promises[0];
        }
        return Promise.all(promises);
    }
    _update() {
        if (this.waitDecoratorsLength > 0) {
            for (let i = 0; i < this.waitDecorators.length; i++) {
                if (this.waitDecorators[i]) {
                    let status = this.waitDecorators[i]._update(this._currentStatus);
                    if (status !== Status_1.default.WAIT) {
                        this.waitDecoratorsLength--;
                        this.waitDecorators[i] = null;
                    }
                }
            }
            if (this.waitDecoratorsLength === 0) {
                let success = this.start();
                this._currentStatus = success ? Status_1.default.IN_PROGRESS : Status_1.default.FAILED;
                if (!success) {
                    this._stop();
                }
            }
            else {
                return Status_1.default.IN_PROGRESS;
            }
        }
        if (this._currentStatus === Status_1.default.PAUSED) {
            let status = this._currentStatus;
            if (this._decorators.length) {
                for (let i = 0; i < this._decorators.length; i++) {
                    status = this._decorators[i]._update(this._currentStatus);
                    if (status !== Status_1.default.IN_PROGRESS) {
                        this._stop();
                        return status;
                    }
                }
            }
            return this._currentStatus;
        }
        else if (this._currentStatus === Status_1.default.IN_PROGRESS) {
            let tempStatus = this.update();
            if (tempStatus !== Status_1.default.IN_PROGRESS) {
                this._currentStatus = tempStatus;
                this._stop();
            }
            if (this._decorators.length) {
                for (let i = 0; i < this._decorators.length; i++) {
                    tempStatus = this._decorators[i]._update(this._currentStatus);
                    if (tempStatus !== Status_1.default.IN_PROGRESS) {
                        this._stop();
                        this._currentStatus = tempStatus;
                        return this._currentStatus;
                    }
                }
            }
            return this._currentStatus;
        }
        else if (this._currentStatus === Status_1.default.SUCCEEDED) {
            return Status_1.default.SUCCEEDED;
        }
        else {
            return Status_1.default.FAILED;
        }
    }
}
exports.default = Behavior;

},{"./BaseElement":2,"./Status":10}],4:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
class BehaviorEmitter extends events_1.EventEmitter {
    constructor() {
        super();
    }
}
exports.default = BehaviorEmitter;

},{"events":undefined}],5:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
class BehaviorTree extends events_1.EventEmitter {
    constructor(root, blackboard, notepad, result, emitter) {
        super();
        this.root = root;
        this.blackboard = blackboard;
        this.notepad = notepad;
        this.result = result;
        this.emitter = emitter;
    }
    get currentStatus() {
        return this.root.currentStatus;
    }
    start() {
        this.emit('start');
        return this.root._start();
    }
    stop() {
        const rtn = this.root._stop();
        this.emit('stop');
        return rtn;
    }
    pause() {
        this.root._pause();
        this.emit('pause');
    }
    unpause() {
        this.root._unpause();
        this.emit('unpause');
    }
    update() {
        return this.root._update();
    }
    destroy() {
        this.emit('destroy');
        this.removeAllListeners();
        if (this.root) {
            this.root.destroy();
        }
        this.root = null;
        this.blackboard = null;
        this.result = null;
        this.notepad = null;
        if (this.emitter) {
            this.emitter.removeAllListeners();
        }
        this.emitter = null;
    }
    stopAndDestroy() {
        return this.stop().catch(() => { }).then(() => {
            this.destroy();
        });
    }
}
exports.default = BehaviorTree;

},{"events":undefined}],6:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class Blackboard {
}
exports.default = Blackboard;

},{}],7:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Status_1 = require("./Status");
const BaseElement_1 = require("./BaseElement");
class Decorator extends BaseElement_1.default {
    constructor(options, defaultOptions) {
        super(options, defaultOptions);
        this.behavior = null;
    }
    start() {
        return true;
    }
    destroy() {
        this.behavior = null;
        super.destroy();
    }
    _start() {
        let success = this.start();
        this._currentStatus = success ? Status_1.default.IN_PROGRESS : Status_1.default.FAILED;
        return success;
    }
    _stop() {
        this._currentStatus = Status_1.default.INTERRUPTED;
        return this.stop();
    }
    _update(result) {
        this._currentStatus = this.update(result);
        return this._currentStatus;
    }
}
exports.default = Decorator;

},{"./BaseElement":2,"./Status":10}],8:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const path = require("path");
const callsite = require("callsite");
const Runtime_1 = require("../Runtime");
const BehaviorEmitter_1 = require("./BehaviorEmitter");
const Blackboard_1 = require("./Blackboard");
const BehaviorTree_1 = require("./BehaviorTree");
const Status_1 = require("./Status");
const log_1 = require("./log");
class Factory {
    constructor(bt) {
        this._behaviors = {};
        this.Status = Status_1.default;
        this.blackboard = new Blackboard_1.default();
        this.emitter = new BehaviorEmitter_1.default();
        Object.assign(this, bt);
        this.registerCore();
    }
    register(name, namespace, classRef) {
        let ns = this._behaviors[namespace];
        if (!ns) {
            ns = this._behaviors[namespace] = {};
        }
        ns[name] = classRef;
    }
    registerCore() {
        const namespace = 'core';
        const all = Object.assign({}, this.behaviors, this.decorators);
        for (let name in all) {
            this.register(name, namespace, all[name]);
        }
    }
    getBehaviorConstructor(behavior, namespace) {
        let ns = this._behaviors[namespace || 'core'];
        if (ns) {
            return ns[behavior];
        }
    }
    getBlackboard() {
        return this.blackboard;
    }
    getEmitter() {
        return this.emitter;
    }
    create(uri, overrides = {}) {
        let createTree;
        if (typeof uri === 'string') {
            let calleeDirname = callsite()[1].getFileName();
            let treePath = this.getFilePathFromCallee(calleeDirname, uri);
            try {
                createTree = require(treePath);
            }
            catch (e) {
                console.error(e);
                throw new Error(uri + ' is not a valid behavior tree');
            }
        }
        else {
            createTree = uri;
        }
        let blackboard = overrides.blackboard || this.blackboard;
        let notepad = overrides.notepad || {};
        let result = {};
        let tree = createTree(blackboard, notepad, result, this.emitter);
        let map = {};
        let i, j, node, id;
        let ids = Object.keys(tree);
        let namespace = "", ns;
        for (i = 0; i < ids.length; i++) {
            id = ids[i];
            if (id === 'meta') {
                continue;
            }
            node = tree[id];
            if (typeof node === 'function') {
                tree[id] = node.bind({})({});
            }
        }
        for (i = 0; i < ids.length; i++) {
            id = ids[i];
            if (id === 'meta') {
                continue;
            }
            node = tree[id];
            namespace = node['asset-pack'] || "core";
            if (namespace === "project" && overrides.assetPack) {
                namespace = overrides.assetPack;
            }
            ns = this._behaviors[namespace];
            if (!ns) {
                throw new Error("Namespace '" + namespace + "' is not registered with the behavior factory");
            }
            else if (!ns[node.class]) {
                throw new Error("Behavior '" + node.class + "' in namespace '" + namespace + "' is not registered with the behavior factory");
            }
            else if (Array.isArray(node.args)) {
                throw new Error("Behavior '" + node.class + "' options are invalid, re-run behaviorify");
            }
            let Constructor = ns[node.class];
            let options = Object.assign({
                name: node.name,
                emitter: this.emitter,
                blackboard: blackboard,
                assetPack: overrides.assetPack || ""
            }, node.options || {});
            log_1.default.debug('Constructing beh', node.class, node.name, node.options);
            map[id] = new Constructor(options);
        }
        let possibleRoots = {};
        for (i = 0; i < ids.length; i++) {
            id = ids[i];
            if (id === 'meta') {
                continue;
            }
            node = tree[id];
            if (!node.parent) {
                possibleRoots[node.id] = true;
            }
            if (node.skipped) {
                delete possibleRoots[node.id];
                continue;
            }
            let behavior = map[node.id];
            if (node.children) {
                let children = [];
                for (j = 0; j < node.children.length; j++) {
                    let childId = node.children[j];
                    let child = map[childId];
                    if (!tree[childId].skipped) {
                        children.push(child);
                    }
                }
                behavior.children = children;
            }
            if (node.decorators) {
                let decorators = [];
                for (j = 0; j < node.decorators.length; j++) {
                    let decorator = map[node.decorators[j]];
                    delete possibleRoots[node.decorators[j]];
                    if (!tree[node.decorators[j]].skipped) {
                        decorators.push(decorator);
                    }
                }
                if (decorators.length > 0) {
                    behavior.decorators = decorators;
                }
            }
        }
        let root = map[Object.keys(possibleRoots)[0]];
        return new BehaviorTree_1.default(root, this.blackboard, notepad, result, this.emitter);
    }
    run(uri, overrides = {}, onFinishedCallback = null) {
        if (typeof (overrides) === "function") {
            onFinishedCallback = overrides;
            overrides = {};
        }
        if (typeof uri === 'string') {
            let calleeDirname = callsite()[1].getFileName();
            uri = this.getFilePathFromCallee(calleeDirname, uri);
        }
        const behaviorTree = this.create(uri, overrides);
        function doUpdate(elapsed) {
            if (behaviorTree.currentStatus === Status_1.default.IN_PROGRESS) {
                behaviorTree.update();
            }
            else if (behaviorTree.currentStatus === Status_1.default.FAILED ||
                behaviorTree.currentStatus === Status_1.default.SUCCEEDED ||
                behaviorTree.currentStatus === Status_1.default.INTERRUPTED) {
                stopUpdate();
            }
        }
        function clearTimer() {
            Runtime_1.default.instance.timer.removeListener('update', doUpdate);
        }
        function stopUpdate() {
            clearTimer();
            if (onFinishedCallback) {
                let callback = onFinishedCallback;
                onFinishedCallback = null;
                callback(behaviorTree.currentStatus);
            }
        }
        function startUpdate() {
            clearTimer();
            Runtime_1.default.instance.timer.on('update', doUpdate);
        }
        behaviorTree.on('start', startUpdate);
        behaviorTree.on('stop', stopUpdate);
        behaviorTree.on('destroy', clearTimer);
        behaviorTree.start();
        return behaviorTree;
    }
    getFilePathFromCallee(calleeDirname, uri) {
        let filePath;
        uri = uri.substr(0, uri.lastIndexOf(path.parse(uri).ext));
        if (!path.isAbsolute(uri)) {
            if (calleeDirname.indexOf('file://') === 0) {
                calleeDirname = calleeDirname.substr(7);
            }
            filePath = path.join(calleeDirname, '..', uri);
        }
        else {
            filePath = uri;
        }
        return filePath;
    }
}
exports.default = Factory;

},{"../Runtime":1,"./BehaviorEmitter":4,"./BehaviorTree":5,"./Blackboard":6,"./Status":10,"./log":49,"callsite":undefined,"path":undefined}],9:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Status_1 = require("./Status");
const Behavior_1 = require("./Behavior");
class ParentBehavior extends Behavior_1.default {
    constructor(options, defaultOptions) {
        super(options, Object.assign({
            children: []
        }, defaultOptions || {}));
        this.children = this.options.children;
    }
    destroy() {
        this._children.forEach((child) => {
            child.destroy();
        });
        this._children = null;
        super.destroy();
    }
    get children() { return this._children; }
    set children(children) {
        for (let i = 0; i < children.length; i++) {
            children[i].parent = this;
        }
        this._children = children;
    }
    _stop() {
        const promises = [];
        if (this.children.length) {
            this.children.forEach(function (child) {
                if (child.currentStatus === Status_1.default.IN_PROGRESS) {
                    promises.push(child._stop());
                }
            });
        }
        promises.push(super._stop());
        if (promises.length === 0) {
            return Promise.resolve();
        }
        else if (promises.length === 1) {
            return promises[0];
        }
        return Promise.all(promises);
    }
}
exports.default = ParentBehavior;

},{"./Behavior":3,"./Status":10}],10:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var Status;
(function (Status) {
    Status[Status["SUCCEEDED"] = 0] = "SUCCEEDED";
    Status[Status["FAILED"] = 1] = "FAILED";
    Status[Status["INTERRUPTED"] = 2] = "INTERRUPTED";
    Status[Status["IN_PROGRESS"] = 3] = "IN_PROGRESS";
    Status[Status["INVALID"] = 4] = "INVALID";
    Status[Status["PAUSED"] = 5] = "PAUSED";
    Status[Status["WAIT"] = 6] = "WAIT";
})(Status || (Status = {}));
exports.default = Status;

},{}],11:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Behavior_1 = require("../Behavior");
const Status_1 = require("../Status");
const Runtime_1 = require("../../Runtime");
class Blink extends Behavior_1.default {
    start() {
        Runtime_1.default.instance.expression.blink();
        return true;
    }
    update() {
        return Status_1.default.SUCCEEDED;
    }
}
exports.default = Blink;

},{"../../Runtime":1,"../Behavior":3,"../Status":10}],12:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Behavior_1 = require("../Behavior");
const Status_1 = require("../Status");
class ExecuteScript extends Behavior_1.default {
    start() {
        this.options.exec();
        return true;
    }
    update() {
        return Status_1.default.SUCCEEDED;
    }
}
exports.default = ExecuteScript;

},{"../Behavior":3,"../Status":10}],13:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Behavior_1 = require("../Behavior");
const Status_1 = require("../Status");
class ExecuteScriptAsync extends Behavior_1.default {
    constructor(options) {
        super(options);
        this.status = Status_1.default.INVALID;
    }
    start() {
        this.status = Status_1.default.IN_PROGRESS;
        this.options.exec(this.onSucceed.bind(this), this.onFail.bind(this));
        return true;
    }
    update() {
        return this.status;
    }
    onSucceed() {
        this.status = Status_1.default.SUCCEEDED;
    }
    onFail() {
        this.status = Status_1.default.FAILED;
    }
}
exports.default = ExecuteScriptAsync;

},{"../Behavior":3,"../Status":10}],14:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Behavior_1 = require("../Behavior");
const Status_1 = require("../Status");
const Runtime_1 = require("../../Runtime");
class LookAt extends Behavior_1.default {
    constructor(options) {
        super(options, {
            isContinuous: false
        });
        this.status = Status_1.default.INVALID;
    }
    start() {
        this.status = Status_1.default.IN_PROGRESS;
        let position = this.options.getTarget();
        Runtime_1.default.instance.expression.acquireTarget({
            position
        }).then((handle) => {
            this.handle = handle;
            return this.handle.promise;
        }).then((status) => {
            this.handle = undefined;
            this.status = Status_1.default.SUCCEEDED;
        });
        return true;
    }
    stop() {
        if (this.handle) {
            return this.handle.cancel();
        }
        else {
            return Promise.resolve();
        }
    }
    update() {
        return this.status;
    }
    destroy() {
        super.destroy();
        this.handle = undefined;
    }
}
exports.default = LookAt;

},{"../../Runtime":1,"../Behavior":3,"../Status":10}],15:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Behavior_1 = require("../Behavior");
const Status_1 = require("../Status");
const Runtime_1 = require("../../Runtime");
const Mim_1 = require("./Mim");
const GenerateListConfig_1 = require("../mim/GenerateListConfig");
const View_1 = require("../../rendering/gui/views/View");
const ActionData_1 = require("../../rendering/gui/actions/ActionData");
const TouchManager_1 = require("../../rendering/gui/TouchManager");
const MENU_MIM_CONFIG = {
    mim_id: Mim_1.MENU_NAME,
    mim_type: "optional-response",
    rule_name: null,
    timeout: 10,
    barge_in: false,
    prompts: [
        {
            prompt_category: "Entry-Core",
            prompt_sub_category: "AN",
            index: 1,
            condition: "",
            prompt: "",
            media: "silence",
            prompt_id: ""
        }
    ],
    num_tries_for_gui: 0,
    es_auto_tagging: true,
    ignore_no_match: true
};
const DEFAULT_CLOSE = {
    remove: true
};
class Menu extends Behavior_1.default {
    constructor(options) {
        super(options);
        this.createdMenu = false;
        this.isQuitting = false;
        this.gotPick = false;
        this.getConfig = options.getConfig;
        this.onMenuClosed = options.onMenuClosed;
        this.onItemChosen = options.onItemChosen;
        this.onPositionalSelect = options.onPositionalSelect;
        this.onListClosed = this.onListClosed.bind(this);
        this.onPressEvent = this.onPressEvent.bind(this);
    }
    start() {
        this.status = Status_1.default.IN_PROGRESS;
        const configLoaded = (config) => {
            if (!config) {
                this.status = Status_1.default.FAILED;
                return;
            }
            if (typeof config === 'string') {
                const path = Runtime_1.default.instance.utils.PathUtils.getAssetUri(config, this.assetPack);
                Runtime_1.default.instance.loader.load(path, (err, data) => {
                    if (err) {
                        throw err;
                    }
                    configLoaded(data);
                });
                return;
            }
            if (!config.open) {
                config.open = {
                    pause: false
                };
            }
            else if (!config.open.hasOwnProperty('pause')) {
                config.open.pause = false;
            }
            this.config = config;
            let mimConfig = null;
            let mimPath = null;
            if (config.baseMim) {
                mimPath = config.baseMim;
            }
            else {
                mimConfig = GenerateListConfig_1.mergeDeep({}, MENU_MIM_CONFIG);
                if (config.timeout > 1) {
                    mimConfig.timeout = config.timeout;
                }
                mimConfig.rule_name = config.rule;
            }
            const mimEnd = this.onMimEnd.bind(this);
            let mimOptions = {
                assetPack: this.assetPack,
                onSuccess: mimEnd,
                onFailure: mimEnd,
                onPositionalSelect: this.onPositionalSelect,
                mimConfig: mimConfig,
                mimPath: mimPath,
                guiConfig: config,
                asrMetadata: {
                    skill: this.assetPack
                },
                isMenu: true
            };
            this.mim = new Mim_1.default(mimOptions);
            this.mim.start();
        };
        this.getConfig(configLoaded);
        return true;
    }
    stop() {
        this.status = Status_1.default.INVALID;
        if (this.mim) {
            const activeView = this.mim.activeView;
            if (activeView) {
                activeView.removeListener('press', this.onPressEvent);
                activeView.removeListener(View_1.STATE.CLOSED, this.onListClosed);
            }
            return this.mim.stop();
        }
        return Promise.resolve();
    }
    update() {
        if (this.isQuitting) {
            return Status_1.default.IN_PROGRESS;
        }
        if (this.status !== Status_1.default.IN_PROGRESS) {
            return this.status;
        }
        if (this.mim) {
            this.status = this.mim.update();
            if (this.isQuitting) {
                this.status = Status_1.default.IN_PROGRESS;
            }
            const activeView = this.mim.activeView;
            if (!this.createdMenu && activeView &&
                (activeView.state === View_1.STATE.LOADED || activeView.state === View_1.STATE.OPENED)) {
                activeView.once('press', this.onPressEvent);
                activeView.once(View_1.STATE.CLOSED, this.onListClosed);
                this.createdMenu = true;
                activeView.removeActionsByType(ActionData_1.default.CLOSE_VIEW, TouchManager_1.GESTURE.SWIPE);
            }
        }
        return this.status;
    }
    destroy() {
        super.destroy();
        if (this.mim) {
            this.mim.destroy();
            this.mim = null;
        }
    }
    onPressEvent(event) {
        if (this.gotPick || !this.mim) {
            return;
        }
        this.gotPick = true;
        let transition = this.config.defaultSelect || DEFAULT_CLOSE;
        this.onItemChosen(event, this.mim.activeView, (trans) => {
            transition = trans;
        });
        if (!this.mim) {
            console.error('Menu was destroyed during onItemChosen() - please wait until the behavior returns Status.SUCCEEDED or Status.FAILED from update() to consider it completed');
            return;
        }
        this.mim.viewTransition = transition;
        if (this.mim.activeView) {
            const activeView = this.mim.activeView;
            activeView.removeListener('press', this.onPressEvent);
            activeView.removeListener(View_1.STATE.CLOSED, this.onListClosed);
        }
        this.mim.stop(true);
        if (this.mim.destroyViewPromise) {
            this.mim.destroyViewPromise.then(() => {
                this.status = Status_1.default.SUCCEEDED;
            });
        }
        else {
            this.status = Status_1.default.SUCCEEDED;
        }
    }
    onListClosed() {
        if (this.gotPick || !this.mim) {
            return;
        }
        this.gotPick = true;
        let transition = this.config.defaultClose || DEFAULT_CLOSE;
        let handled = false;
        if (this.onMenuClosed) {
            handled = this.onMenuClosed(false, this.mim.activeView, (trans) => {
                transition = trans;
            });
        }
        if (!this.mim) {
            console.error('Menu was destroyed during onMenuClosed() - please wait until the behavior returns Status.SUCCEEDED or Status.FAILED from update() to consider it completed');
            return;
        }
        this.mim.viewTransition = transition;
        if (this.mim.activeView) {
            const activeView = this.mim.activeView;
            activeView.removeListener(View_1.default.BACK, this.onListClosed);
            activeView.removeListener('press', this.onPressEvent);
            activeView.removeListener(View_1.STATE.CLOSED, this.onListClosed);
        }
        if (!handled) {
            this.isQuitting = true;
            this.mim.activeView.inputLocked = true;
            Runtime_1.default.instance.lifecycle.finished();
        }
        else {
            this.mim.stop();
            if (this.mim.destroyViewPromise) {
                this.mim.destroyViewPromise.then(() => {
                    this.status = Status_1.default.SUCCEEDED;
                });
            }
            else {
                this.status = Status_1.default.SUCCEEDED;
            }
        }
    }
    onMimEnd(results) {
        if (this.gotPick || !this.mim) {
            return;
        }
        this.gotPick = true;
        let transition = this.config.defaultClose || DEFAULT_CLOSE;
        const lastResultState = results.state.lastResultState;
        if (lastResultState === 'noInput' || lastResultState === 'MenuClosed' || lastResultState === 'noMatch') {
            let handled = false;
            if (this.onMenuClosed) {
                handled = this.onMenuClosed(lastResultState === 'noInput' || lastResultState === 'noMatch', this.mim.activeView, (trans) => {
                    transition = trans;
                });
                if (!this.mim) {
                    console.error('Menu was destroyed during onMenuClosed() - please wait until the behavior returns Status.SUCCEEDED or Status.FAILED from update() to consider it completed');
                    return true;
                }
            }
            if (!handled) {
                this.isQuitting = true;
                Runtime_1.default.instance.lifecycle.finished();
            }
        }
        else {
            transition = this.config.defaultSelect || DEFAULT_CLOSE;
            this.onItemChosen(results.asrResults, this.mim.activeView, (trans) => {
                transition = trans;
            });
            if (!this.mim) {
                console.error('Menu was destroyed during onItemChosen() - please wait until the behavior returns Status.SUCCEEDED or Status.FAILED from update() to consider it completed');
                return;
            }
        }
        this.mim.viewTransition = transition;
        if (this.mim.activeView) {
            const activeView = this.mim.activeView;
            activeView.removeListener(View_1.default.BACK, this.onListClosed);
            activeView.removeListener('press', this.onPressEvent);
            activeView.removeListener(View_1.STATE.CLOSED, this.onListClosed);
        }
        return true;
    }
}
exports.default = Menu;

},{"../../Runtime":1,"../../rendering/gui/TouchManager":125,"../../rendering/gui/actions/ActionData":130,"../../rendering/gui/views/View":156,"../Behavior":3,"../Status":10,"../mim/GenerateListConfig":50,"./Mim":16}],16:[function(require,module,exports){
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const fs = require("fs");
const jibo_state_machine_1 = require("jibo-state-machine");
const uuid = require("uuid");
const log_1 = require("./log");
const Behavior_1 = require("../Behavior");
const Status_1 = require("../Status");
const Runtime_1 = require("../../Runtime");
const jibo_plugins_1 = require("jibo-plugins");
const jetstream_client_1 = require("@jibo/jetstream-client");
const MimConfig_1 = require("../mim/MimConfig");
const jibo_embodied_dialog_1 = require("jibo-embodied-dialog");
const MimState_1 = require("../mim/MimState");
const GenerateListConfig_1 = require("../mim/GenerateListConfig");
const MimManager_1 = require("../mim/MimManager");
const ListenEvent_1 = require("../mim/delegates/ListenEvent");
const analytics = require("../mim/analytics/MimAnalytics");
const FaceRenderer_1 = require("../../rendering/FaceRenderer");
const ViewManager_1 = require("../../rendering/gui/ViewManager");
const View_1 = require("../../rendering/gui/views/View");
const EyeView_1 = require("../../rendering/gui/views/EyeView");
const MenuView_1 = require("../../rendering/gui/views/MenuView");
const ActionData_1 = require("../../rendering/gui/actions/ActionData");
const NoInputException = require('../mim/flows/NoInputException');
const NoMatchException = require('../mim/flows/NoMatchException');
class ListenBundle {
    constructor() {
        this.timeout = NaN;
        this.startTime = NaN;
        this.failedToGetListener = false;
    }
}
class MimStates {
    constructor(sm) {
        this.loadConfig = new jibo_state_machine_1.State(sm, 'Load MIM Config');
        this.loadRule = new jibo_state_machine_1.State(sm, 'Load Rule');
        this.choosePrompt = new jibo_state_machine_1.State(sm, 'Choose Prompt');
        this.speak = new jibo_state_machine_1.State(sm, 'Speak');
        this.listen = new jibo_state_machine_1.State(sm, 'Listen');
        this.restartListen = new jibo_state_machine_1.State(sm, 'Restart Listen');
        this.analyzeMimGlobal = new jibo_state_machine_1.State(sm, 'Analyze Mim Global');
        this.analyzeMenuGlobal = new jibo_state_machine_1.State(sm, 'Analyze Menu Global');
        this.analyzeResults = new jibo_state_machine_1.State(sm, 'Analyze Results');
        this.parseSpoof = new jibo_state_machine_1.State(sm, 'Parse Spoofed Utterance');
        this.reportResults = new jibo_state_machine_1.State(sm, 'Report Results');
        this.handleException = new jibo_state_machine_1.State(sm, 'Handle Exception');
        this.waitForHJEnd = new jibo_state_machine_1.State(sm, 'Wait for Hey Jibo end');
        this.loadConfig.addInternalTransition('Config loaded', this.loadRule);
        this.loadConfig.addInternalTransition('AN mim', this.choosePrompt);
        this.loadConfig.addInternalTransition('HJ before/during config for AN', this.waitForHJEnd);
        this.loadRule.addInternalTransition('Rule loading', this.choosePrompt);
        this.loadRule.addInternalTransition('Spoofed utterance during config', this.parseSpoof);
        this.loadRule.addInternalTransition('HJ before/during config for Q/OR', this.waitForHJEnd);
        this.choosePrompt.addInternalTransition('Has prompt', this.speak);
        this.choosePrompt.addInternalTransition('No prompt', this.listen);
        this.choosePrompt.addInternalTransition('No valid prompt on AN mim', this.reportResults);
        this.speak.addInternalTransition('AN speak done or View manually closed', this.reportResults);
        this.speak.addInternalTransition('OR/Q speak done', this.listen);
        this.speak.addInternalTransition('Spoofed utterance', this.parseSpoof);
        this.speak.addInternalTransition('HJ Heard', this.waitForHJEnd);
        this.listen.addInternalTransition('Listen complete', this.analyzeResults);
        this.listen.addInternalTransition('Mim Global', this.analyzeMimGlobal);
        this.listen.addInternalTransition('List Global', this.analyzeMenuGlobal);
        this.listen.addInternalTransition('Premature Timeout', this.restartListen);
        this.listen.addInternalTransition('Spoofed utterance', this.parseSpoof);
        this.listen.addInternalTransition('HJ Heard', this.waitForHJEnd);
        this.listen.addInternalTransition('What Can I Do', this.choosePrompt);
        this.listen.addInternalTransition('View manually closed', this.reportResults);
        this.restartListen.addTransition(new jibo_state_machine_1.TimeoutTransition('5 ms', this.listen, 5));
        this.restartListen.addInternalTransition('View closed while waiting to restart', this.reportResults);
        this.analyzeMimGlobal.addInternalTransition('Quick Global', this.listen);
        this.analyzeMimGlobal.addInternalTransition('Repeat', this.choosePrompt);
        this.analyzeMimGlobal.addInternalTransition('Irrelevant global', this.analyzeResults);
        this.analyzeMenuGlobal.addInternalTransition('Quick Global', this.listen);
        this.analyzeMenuGlobal.addInternalTransition('Irrelevant global', this.analyzeResults);
        this.analyzeMenuGlobal.addInternalTransition('Spoofed utterance', this.parseSpoof);
        this.analyzeMenuGlobal.addInternalTransition('Menu global ends menu', this.reportResults);
        this.parseSpoof.addInternalTransition('Utterance parsed', this.analyzeResults);
        this.analyzeResults.addInternalTransition('MIM success', this.reportResults);
        this.analyzeResults.addInternalTransition('Another try', this.choosePrompt);
        this.analyzeResults.addInternalTransition('Ignore NM', this.listen);
        this.reportResults.addInternalTransition('NM/NI exception', this.handleException);
        this.handleException.addInternalTransition('Exception solved', this.choosePrompt);
        this.waitForHJEnd.addInternalTransition('Recover from HJ', this.choosePrompt);
        this.waitForHJEnd.addInternalTransition('Recover from HJ (menu)', this.listen);
        this.waitForHJEnd.addInternalTransition('View manually closed', this.reportResults);
        this.waitForHJEnd.addInternalTransition('Button pressed while waiting', this.parseSpoof);
    }
}
exports.MENU_NAME = 'Menu_AutoGenerated';
const THANKS_RULE = 'globals/mim_thanks';
const REPEAT_RULE = 'globals/mim_repeat';
const GUI_RULE = 'globals/gui_nav';
const log = log_1.default.createChild('MimBehavior');
function sanitizePromptData(data) {
    let output = {};
    for (let prop in data) {
        if (!data[prop]) {
            output[prop] = data[prop];
            continue;
        }
        if (typeof data[prop].toLog === 'function') {
            output[prop] = data[prop].toLog();
            continue;
        }
        if (/loop|name|user|birth/i.test(prop)) {
            output[prop] = `<User property ${prop} omitted>`;
        }
        output[prop] = data[prop];
    }
    return output;
}
class Mim extends Behavior_1.default {
    constructor(options) {
        super(options);
        this.pausedHotword = null;
        this.isMenu = false;
        this.interactionId = uuid.v4();
        MimManager_1.default.instance.loadMimAssets();
        this.viewTransition = {
            remove: true,
            transitionClose: ViewManager_1.TRANSITION.DOWN
        };
        this.mimPath = options.mimPath;
        this.promptData = null;
        if (options.mimConfig) {
            this.mimConfig = new MimConfig_1.default();
            if (options.isMenu) {
                this.mimConfig.mimId = exports.MENU_NAME;
            }
            this.mimConfig.initWithJSON(options.mimConfig);
        }
        this.isMenu = !!options.isMenu;
        if (options.guiConfig) {
            this.guiConfig = options.guiConfig;
        }
        this.asrMetadata = options.asrMetadata;
        if (!this.asrMetadata) {
            this.asrMetadata = {};
        }
        this.asrMetadata.skill = Runtime_1.default.instance.analytics.currentSkill;
        this.asrMetadata.interactionId = this.interactionId;
        this.checkResult = options.checkResult;
        this.onFailure = options.onFailure;
        this.onSuccess = options.onSuccess || options.onResults;
        this.onPositionalSelect = options.onPositionalSelect;
        this.status = Status_1.default.INVALID;
        this.mimState = new MimState_1.default();
        this.entryPrompt = null;
        this.repeatCount = 0;
        this.mimMachine = new jibo_state_machine_1.StateMachine();
        const states = this.states = new MimStates(this.mimMachine);
        states.loadConfig.onEntry = this.loadMim.bind(this);
        states.loadRule.onEntry = this.loadRule.bind(this);
        states.choosePrompt.onEntry = this.choosePrompt.bind(this);
        states.speak.onEntry = this.speak.bind(this);
        states.speak.onExit = states.speak.onStop = this.stopSpeaking.bind(this);
        states.listen.onEntry = this.startListen.bind(this);
        states.listen.onUpdate = this.updateListen.bind(this);
        states.listen.onStop = this.stopListen.bind(this);
        states.listen.onExit = this.listenExit.bind(this);
        states.analyzeMimGlobal.onEntry = this.analyzeMimGlobal.bind(this);
        states.analyzeMenuGlobal.onEntry = this.analyzeMenuGlobal.bind(this);
        states.analyzeResults.onEntry = this.analyzeResults.bind(this);
        states.parseSpoof.onEntry = this.parseSpoofedUtterance.bind(this);
        states.reportResults.onEntry = this.reportResults.bind(this);
        states.handleException.onEntry = this.handleException.bind(this);
        states.handleException.onUpdate = this.updateException.bind(this);
        states.handleException.onStop = this.stopException.bind(this);
        states.waitForHJEnd.onEntry = this.waitForHJEnd.bind(this);
        states.waitForHJEnd.onStop = states.waitForHJEnd.onExit = this.hjEnded.bind(this);
        this.resetTimeout = this.resetTimeout.bind(this);
        this.onEndEvent = this.onEndEvent.bind(this);
        this.onSpeechEvent = this.onSpeechEvent.bind(this);
        this.onOpenGUIEvent = this.onOpenGUIEvent.bind(this);
        this.onHeyJiboHeard = this.onHeyJiboHeard.bind(this);
        this.recoverFromHJ = this.recoverFromHJ.bind(this);
        this.onViewClosed = this.onViewClosed.bind(this);
    }
    start() {
        if (this.options.getPromptData) {
            this.promptData = this.options.getPromptData();
        }
        if (!this.promptData) {
            this.promptData = {};
        }
        if (this.promptData._state) {
            this.mimState.lastResultState = this.promptData._state;
            delete this.promptData._state;
        }
        this.status = Status_1.default.IN_PROGRESS;
        Runtime_1.default.instance.performance.log('MimStart');
        this.mimMachine.start();
        if (!this.options.ignoreEvents) {
            const mm = MimManager_1.default.instance;
            mm.openGUI.on(this.onOpenGUIEvent);
            mm.handleSpeech.on(this.onSpeechEvent);
            mm.end.on(this.onEndEvent);
            mm.heyJibo.on(this.onHeyJiboHeard);
        }
        return true;
    }
    stop(isMenuTap = false) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.status === Status_1.default.IN_PROGRESS) {
                if (isMenuTap) {
                    analytics.end(this.analyticsBase, analytics.EXIT_TYPE.SUCCESS, analytics.INPUT.TOUCH, '<menu_tap>', analytics.NONE, '', this.lastPromptId, this.mimState.noMatchCount, this.mimState.noInputCount);
                }
                else {
                    const IS = analytics.INTERRUPT_STATE;
                    analytics.end(this.analyticsBase, analytics.EXIT_TYPE.INTERRUPT, analytics.INPUT.INTERRUPT, '', analytics.NONE, this.mimMachine.current === this.states.speak ? IS.SPEECH : IS.LISTEN, this.lastPromptId, this.mimState.noMatchCount, this.mimState.noInputCount);
                }
            }
            if (this.pausedHotword) {
                this.pausedHotword.release();
                this.pausedHotword = null;
            }
            this.cleanUpEvents();
            this.removeView();
            this.mimMachine.stop();
            this.mimMachine.current = null;
            this.unloadRules();
            this.status = Status_1.default.INVALID;
            const listenDelegate = MimManager_1.default.instance.listenDelegate;
            yield listenDelegate.exitActiveMode();
            yield (this.destroyViewPromise || Promise.resolve());
        });
    }
    update() {
        if (this.status !== Status_1.default.IN_PROGRESS) {
            return this.status;
        }
        this.mimMachine.update();
        return this.status;
    }
    destroy() {
        this.status = Status_1.default.INVALID;
        super.destroy();
        this.unloadRules();
        this.cleanUpEvents();
        if (this.pausedHotword) {
            this.pausedHotword.release();
            this.pausedHotword = null;
        }
        this.removeView();
        if (this.mimMachine) {
            this.mimMachine.stop();
        }
        this.mimMachine = null;
        this.mimState = null;
        this.checkResult = null;
        this.onFailure = null;
        this.onSuccess = null;
        this.destroyViewPromise = null;
        this.viewConfig = null;
    }
    removeView() {
        if (this.activeView) {
            const listenDelegate = MimManager_1.default.instance.listenDelegate;
            listenDelegate.exitActiveMode();
            const activeView = this.activeView;
            const views = Runtime_1.default.instance.face.views;
            if (views.currentView === activeView) {
                if (this.viewEvents) {
                    for (const evType in this.viewEvents) {
                        activeView.removeListener(evType, this.viewEvents[evType]);
                    }
                }
                activeView.removeListener(View_1.default.BACK, this.onViewClosed);
                if (this.viewTransition === 'remain') {
                    activeView.inputLocked = true;
                    this.activeView = null;
                    return;
                }
                else {
                    this.destroyViewPromise = new Promise((resolve, reject) => {
                        Runtime_1.default.instance.face.views.changeView(this.viewTransition, () => {
                            resolve();
                            this.destroyViewPromise = null;
                        }, () => {
                            resolve();
                            this.destroyViewPromise = null;
                        });
                    });
                }
            }
            this.activeView = null;
        }
    }
    unloadRules() {
    }
    cleanUpEvents() {
        const mm = MimManager_1.default.instance;
        mm.openGUI.removeListener(this.onOpenGUIEvent);
        mm.handleSpeech.removeListener(this.onSpeechEvent);
        mm.end.removeListener(this.onEndEvent);
        mm.heyJibo.removeListener(this.onHeyJiboHeard);
    }
    openGUI() {
        if (this.activeView) {
            return;
        }
        const mimConfig = this.mimConfig;
        const views = Runtime_1.default.instance.face.views;
        let config;
        if (this.guiConfig) {
            config = this.guiConfig;
        }
        else if (mimConfig.gui) {
            if (mimConfig.gui.type === 'Menu') {
                config = GenerateListConfig_1.default(mimConfig.gui.data);
            }
            else if (mimConfig.gui.type === 'File') {
                try {
                    const configPath = jibo_plugins_1.PathUtils.getAssetUri(mimConfig.gui.data, this.assetPack);
                    config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
                }
                catch (e) {
                    log.warn(`Error when reading MIM GUI json:`, e, `MIM Info: ${this.loggingLead}`);
                    mimConfig.gui = null;
                    return;
                }
            }
            else if (mimConfig.gui.type === 'Javascript') {
                config = mimConfig.getJavascriptGUI(this.promptData);
                if (!config) {
                    mimConfig.gui = null;
                    return;
                }
            }
        }
        this.viewConfig = config;
        if (views.currentView && views.currentView.id === config.viewConfig.id) {
            this.activeView = views.currentView;
        }
        else {
            this.activeView = views.createView(config.viewConfig.type || 'MenuView', config);
            const open = config.open || {};
            if (views.hasView(this.activeView.id)) {
                open.removeToInclude = this.activeView.id;
            }
            const shouldPause = mimConfig.gui && (mimConfig.gui.pause || mimConfig.gui.pause === undefined);
            if (!open.hasOwnProperty('pause') && shouldPause) {
                open.pause = !!views.currentView;
                if (views.currentView && views.currentView.type === EyeView_1.default.DEFAULT_TYPE && this.activeView instanceof MenuView_1.default) {
                    this.activeView.addTransition(View_1.default.PAUSED, true, this.activeView.openFromEye, ViewManager_1.TRANSITION.NONE);
                    this.activeView.addTransition(View_1.default.PAUSED, false, this.activeView.closeToEye, ViewManager_1.TRANSITION.NONE);
                }
            }
            open.addView = this.activeView;
            views.changeView(open, () => {
            }, () => {
                if (this.mimState && !this.mimState.done) {
                    if (this.isMenu) {
                        this.stop();
                        this.status = Status_1.default.FAILED;
                    }
                    else {
                        log.warn(`Mim ${mimConfig.mimId} failed to open view, forcing eye view`);
                        views.forceEyeView();
                    }
                }
            });
        }
        if (this.activeView) {
            this.activeView.once(View_1.default.BACK, this.onViewClosed);
        }
        else {
            log.warn(`activeView was null right after it should have been set/created. Current behavior status: ${Status_1.default[this.status]}`);
        }
    }
    onOpenGUIEvent() {
        if (this.status !== Status_1.default.IN_PROGRESS) {
            return;
        }
        const current = this.mimMachine.current;
        const states = this.states;
        if (current !== states.loadConfig) {
            this.openGUI();
        }
    }
    onSpeechEvent(utterance) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.status !== Status_1.default.IN_PROGRESS) {
                return;
            }
            const current = this.mimMachine.current;
            const states = this.states;
            if (typeof utterance === 'string') {
                utterance = {
                    intent: utterance,
                    entities: {},
                    rules: null
                };
            }
            if (typeof utterance.intent !== 'string' || !utterance.entities) {
                log.warn('Received invalid utterance for fake NLU', utterance);
                return;
            }
            utterance.rules = this.mimConfig.ruleNames;
            if (current === states.speak || current === states.listen ||
                current === states.analyzeMenuGlobal || current === states.waitForHJEnd) {
                if (current === states.speak) {
                    MimManager_1.default.instance.speakDelegate.stop();
                    Runtime_1.default.instance.embodied.listen.disableOnce();
                    Runtime_1.default.instance.jetstream.startLocalTurn({
                        nluRules: utterance.rules,
                        clientNLU: utterance
                    }).catch((err) => {
                        log.error('Unable to start clientNLU local turn', err);
                    });
                }
                else if (current === states.listen) {
                    if (this.listen.listener && !this.listen.listener.stopped) {
                        yield this.listen.listener.updateTurn(utterance);
                    }
                    else {
                        Runtime_1.default.instance.embodied.listen.disableOnce();
                        Runtime_1.default.instance.jetstream.startLocalTurn({
                            nluRules: utterance.rules,
                            clientNLU: utterance
                        }).catch((err) => {
                            log.error('Unable to start clientNLU local turn', err);
                        });
                    }
                }
                current.transitionTo(states.parseSpoof, utterance);
            }
            else if (current === states.loadConfig) {
                this.queuedState = { state: states.parseSpoof, data: utterance };
            }
        });
    }
    onEndEvent(data) {
        if (this.status !== Status_1.default.IN_PROGRESS) {
            return;
        }
        const current = this.mimMachine.current;
        const states = this.states;
        if (current === states.speak || current === states.listen ||
            current === states.loadConfig || current === states.analyzeMenuGlobal) {
            if (!data) {
                this.stop();
                this.status = Status_1.default.SUCCEEDED;
            }
            else {
            }
        }
    }
    onHeyJiboHeard() {
        if (this.status !== Status_1.default.IN_PROGRESS) {
            return;
        }
        const current = this.mimMachine.current;
        const states = this.states;
        if (current === states.speak) {
            if (current === states.speak) {
                MimManager_1.default.instance.speakDelegate.stop();
            }
            current.transitionTo(states.waitForHJEnd);
        }
        else if (current === states.loadConfig) {
            this.queuedState = { state: states.waitForHJEnd, data: null };
        }
    }
    onViewClosed() {
        this.mimState.lastResultState = MimState_1.States.MENU_CLOSED;
        if (this.mimConfig.mimType === MimConfig_1.MimTypes.QUESTION) {
            this.mimState.failure = true;
        }
        if (!this.exitInputType) {
            this.exitInputType = analytics.INPUT.TOUCH;
        }
        if (this.mimMachine.current.transitions.find((item) => item.getDestinationState() === this.states.reportResults)) {
            this.mimMachine.current.transitionTo(this.states.reportResults);
        }
        else {
            log.warn(`Attempted to transition due to view closing from ${this.mimMachine.current.name} to ${this.states.reportResults.name}, which isn't allowed.`);
        }
    }
    loadMim(transition, result) {
        const jibo = Runtime_1.default.instance;
        let loadPromise;
        if (this.mimConfig && this.isMenu) {
            jibo.performance.log('MimDataLoadSkipped', 'Mim data already provided');
            this.asrMetadata.mimType = MimConfig_1.MimTypes.OPTIONAL_RESPONSE;
            this.asrMetadata.mimId = 'menu:' + this.guiConfig.viewConfig.id;
            this.loggingLead = `Interaction UUID[${this.interactionId}] MIM ID[${this.asrMetadata.mimId}] MIM Type[${this.asrMetadata.mimType}]`;
            this.analyticsBase = {
                mim_name: this.asrMetadata.mimId,
                mim_type: this.asrMetadata.mimType,
                interaction_id: this.interactionId
            };
            loadPromise = Promise.resolve();
        }
        else {
            const assetPack = this.assetPack;
            jibo.performance.log('MimDataLoadBegin');
            loadPromise = Promise.all([
                this.mimConfig ? Promise.resolve(this.mimConfig) : MimConfig_1.default.load(jibo_plugins_1.PathUtils.getAssetUri(this.mimPath, assetPack)),
                MimManager_1.default.instance.loadMimKB(assetPack)
            ])
                .then((result) => {
                if (this.status !== Status_1.default.IN_PROGRESS) {
                    return;
                }
                if (!(result[0] instanceof MimConfig_1.default)) {
                    log.error(`Error: Cannot load Mim File for ${this.mimPath}!`, result);
                    this.status = Status_1.default.FAILED;
                    return;
                }
                jibo.performance.log('MimDataLoadComplete');
                this.assetPackNode = result[1];
                this.mimConfig = result[0];
                this.asrMetadata.mimType = this.mimConfig.mimType;
                this.asrMetadata.mimId = this.mimConfig.mimId;
                if (this.guiConfig) {
                    this.asrMetadata.mimId = 'menu:' + this.guiConfig.viewConfig.id;
                    this.asrMetadata.mimType = MimConfig_1.MimTypes.OPTIONAL_RESPONSE;
                }
                this.loggingLead = `Interaction UUID[${this.interactionId}] MIM ID[${this.asrMetadata.mimId}] MIM Type[${this.asrMetadata.mimType}]`;
                this.analyticsBase = {
                    mim_name: this.asrMetadata.mimId,
                    mim_type: this.asrMetadata.mimType,
                    interaction_id: this.interactionId
                };
            });
        }
        loadPromise.then(() => {
            if (this.status !== Status_1.default.IN_PROGRESS) {
                return;
            }
            log.debug(`Starting MIM - ${this.loggingLead} Mim Variable Assignments[${JSON.stringify(sanitizePromptData(this.promptData))}]`);
            analytics.launch(this.analyticsBase);
            jibo.autobot.log('MIM Start', this.mimConfig.original);
            if (this.mimConfig.mimType === MimConfig_1.MimTypes.ANNOUNCEMENT) {
                if (this.queuedState) {
                    const queuedState = this.queuedState;
                    this.queuedState = null;
                    this.states.loadRule.transitionTo(queuedState.state, queuedState.data);
                }
                else if (MimManager_1.default.instance.isHeyJiboActive) {
                    this.states.loadConfig.transitionTo(this.states.waitForHJEnd);
                }
                else {
                    this.states.loadConfig.transitionTo(this.states.choosePrompt);
                }
            }
            else {
                if (MimManager_1.default.instance.isHeyJiboActive && !this.isMenu) {
                    this.queuedState = { state: this.states.waitForHJEnd, data: null };
                }
                this.states.loadConfig.transitionTo(this.states.loadRule);
            }
        }, reason => {
            log.error('Failure to load mim config: ', reason);
            this.status = Status_1.default.FAILED;
        });
    }
    loadRule(transition, result) {
        this.mimConfig.calculateRules(this.promptData);
        if (this.queuedState) {
            const queuedState = this.queuedState;
            this.queuedState = null;
            this.states.loadRule.transitionTo(queuedState.state, queuedState.data);
        }
        else {
            this.states.loadRule.transitionTo(this.states.choosePrompt);
        }
    }
    choosePrompt(transition, result) {
        const mimState = this.mimState;
        const mimConfig = this.mimConfig;
        const jibo = Runtime_1.default.instance;
        if (mimState.errors >= 1 && mimState.shouldShowGUI(mimConfig)) {
            MimManager_1.default.instance.shouldShowGUI = true;
        }
        const currentView = jibo.face.views.currentView;
        const shouldShow = MimManager_1.default.instance.shouldShowGUI || mimState.shouldShowGUI(mimConfig);
        if (this.guiConfig || (mimConfig.hasGui && shouldShow &&
            (mimState.shouldShowGUI(mimConfig) || !currentView ||
                currentView.category === jibo.face.views.CATEGORY.EYE))) {
            this.openGUI();
        }
        const home = jibo.utils.Location.jiboHome;
        this.promptData._now = new jibo.utils.DateTime(null, null, home.timezone);
        this.promptData._home = home;
        let promptText = '';
        const lastResultState = mimState.lastResultState;
        jibo.performance.log('MimPromptSelectionStart', `MIM ID: ${mimConfig.mimId} State: ${lastResultState}`);
        if (lastResultState === MimState_1.States.REPEAT) {
            const repeat = MimManager_1.default.instance.repeat.getRepeat(mimConfig.mimType, this.repeatCount);
            if (repeat.prompt) {
                promptText = repeat.prompt;
            }
            if (repeat.action === 'verbose' && mimConfig.hasVerbosePrompt()) {
                mimState.lastResultState = MimState_1.States.VERBOSE;
                const prompt = mimConfig.getPromptText(mimState, this.promptData, this.assetPackNode);
                promptText += prompt.text;
                this.asrMetadata.lastPromptId = this.lastPromptId = prompt.id;
                this.mimState.promptAutoRules = prompt.autoRuleOverride;
            }
            else if (repeat.action !== 'exit') {
                this.asrMetadata.lastPromptId = this.lastPromptId = this.entryPrompt.id;
                promptText += this.entryPrompt.text;
                this.mimState.promptAutoRules = this.entryPrompt.autoRuleOverride;
            }
            this.mimState.promptText = promptText.trim();
        }
        else if (lastResultState === MimState_1.States.THANKS) {
            let prompt;
            if (mimConfig.hasThanksPrompt()) {
                prompt = mimConfig.getPromptText(mimState, this.promptData, this.assetPackNode);
            }
            else {
                prompt = MimManager_1.default.instance.thanksResponse.getPromptText(null, null, MimManager_1.default.instance.jiboRotationNode);
            }
            this.asrMetadata.lastPromptId = this.lastPromptId = prompt.id;
            this.mimState.promptText = promptText = prompt.text.trim();
            this.mimState.promptAutoRules = prompt.autoRuleOverride;
        }
        else {
            const prompt = mimConfig.getPromptText(mimState, this.promptData, this.assetPackNode);
            this.asrMetadata.lastPromptId = this.lastPromptId = prompt.id;
            this.mimState.promptText = promptText = prompt.text.trim();
            this.mimState.promptAutoRules = prompt.autoRuleOverride;
            if (lastResultState === MimState_1.States.ENTRY && this.entryPrompt === null) {
                this.entryPrompt = prompt;
            }
        }
        jibo.performance.log('MimPromptSelectionEnd');
        jibo.autobot.log('MIMPromptSelected', this.lastPromptId, promptText);
        if (promptText) {
            this.states.choosePrompt.transitionTo(this.states.speak);
        }
        else {
            if (this.lastPromptId === null) {
                log.warn(`Unable to find a valid prompt for mim ${this.mimConfig.mimId} - last result state: ${mimState.lastResultState}, prompt data: ${JSON.stringify(sanitizePromptData(this.promptData))}`);
            }
            else {
                log.debug(`Silent Prompt Selected - ${this.loggingLead}`);
            }
            if (this.mimConfig.mimType === MimConfig_1.MimTypes.ANNOUNCEMENT) {
                this.states.choosePrompt.transitionTo(this.states.reportResults);
            }
            else {
                this.states.choosePrompt.transitionTo(this.states.listen, true);
            }
        }
    }
    speak(transition, result) {
        const text = this.mimState.promptText;
        const autoRules = this.mimState.promptAutoRules === null ? this.mimConfig.esAutoTagging : this.mimState.promptAutoRules;
        const options = {
            text: text,
            disableAutoRules: autoRules === false,
            followedByListen: this.mimConfig.mimType !== MimConfig_1.MimTypes.ANNOUNCEMENT,
            autoRuleConfig: undefined
        };
        if (typeof autoRules !== 'boolean') {
            options.autoRuleConfig = autoRules;
        }
        const promptStart = Date.now();
        const originalText = text ? this.mimConfig.getOriginalPromptText(this.lastPromptId) : '';
        log.debug(`Playing Prompt - ${this.loggingLead} Last Prompt Id[${this.lastPromptId}] Prompt[${originalText}]`);
        let performanceMimPromptData = {
            "MimPromptData": [
                { "InteractionUUID": this.interactionId },
                { "MIM_ID": this.asrMetadata.mimId },
                { "MIM_Type": this.asrMetadata.mimType },
                { "LastPromptId": this.lastPromptId },
                { "Prompt": text },
                { "MimVariableAssignments": this.promptData }
            ]
        };
        const jibo = Runtime_1.default.instance;
        const strippedText = text.replace(/<[^>]*>/g, '');
        if (/(hey|hay)\s+jibo/i.test(strippedText)) {
            this.pausedHotword = jibo.jetstream.setHotwordMode(jibo.jetstream.types.HotwordListenMode.Disabled);
        }
        jibo.performance.log('MimPromptData', JSON.stringify(performanceMimPromptData));
        jibo.autobot.log('MimPromptData', JSON.stringify(performanceMimPromptData));
        jibo.autobot.log('MimSpeechStart', options.text);
        jibo.performance.log('MimSpeechStart');
        MimManager_1.default.instance.speakDelegate.speak(options.text, options, options.autoRuleConfig)
            .then(() => {
            if (this.pausedHotword) {
                this.pausedHotword.release();
                this.pausedHotword = null;
            }
            if (this.status !== Status_1.default.IN_PROGRESS ||
                this.mimMachine.current !== this.states.speak) {
                return;
            }
            jibo.autobot.log('MimSpeechEnd');
            jibo.performance.log('MimSpeechEnd');
            log.debug(`Prompt Complete - ${this.loggingLead} Last Prompt Id[${this.lastPromptId}] Duration[${Date.now() - promptStart}ms]`);
            if (this.repeatCount >= MimManager_1.default.instance.repeat.maxRepeat) {
                jibo.lifecycle.finished();
                return;
            }
            if (this.mimState.lastResultState === MimState_1.States.THANKS &&
                this.mimConfig.thanksHandling === MimConfig_1.ThanksOptions.RESPOND_AND_END) {
                this.states.speak.transitionTo(this.states.reportResults);
                return;
            }
            if (this.mimConfig.mimType === MimConfig_1.MimTypes.ANNOUNCEMENT) {
                this.states.speak.transitionTo(this.states.reportResults);
            }
            else {
                this.states.speak.transitionTo(this.states.listen, true);
            }
        })
            .catch(e => {
            if (this.pausedHotword) {
                this.pausedHotword.release();
                this.pausedHotword = null;
            }
            jibo.autobot.log('MimSpeechError', e);
            log.warn('Error when speaking:', e, `Mim Info: ${this.loggingLead}`);
            if (this.status !== Status_1.default.IN_PROGRESS) {
                return;
            }
            if (this.mimMachine.current === this.states.speak) {
                if (this.mimState.lastResultState === MimState_1.States.THANKS &&
                    this.mimConfig.thanksHandling === MimConfig_1.ThanksOptions.RESPOND_AND_END) {
                    this.states.speak.transitionTo(this.states.reportResults);
                    return;
                }
                if (this.mimConfig.mimType === MimConfig_1.MimTypes.ANNOUNCEMENT) {
                    this.states.speak.transitionTo(this.states.reportResults);
                }
                else {
                    this.states.speak.transitionTo(this.states.listen, true);
                }
            }
        });
    }
    stopSpeaking() {
        if (this.pausedHotword) {
            this.pausedHotword.release();
            this.pausedHotword = null;
        }
        MimManager_1.default.instance.speakDelegate.stop();
    }
    startListen(transition, resetTimeout) {
        return __awaiter(this, void 0, void 0, function* () {
            if (this.status !== Status_1.default.IN_PROGRESS) {
                return;
            }
            this.asrResults = null;
            let listen = this.listen;
            if (!listen) {
                resetTimeout = true;
            }
            if (resetTimeout) {
                listen = this.listen = new ListenBundle();
                listen.startTime = Date.now();
            }
            const mimConfig = this.mimConfig;
            const ignoreSimulator = mimConfig.mimType === MimConfig_1.MimTypes.OPTIONAL_RESPONSE || MimManager_1.default.instance.timeoutIgnoresSimulator;
            const jibo = Runtime_1.default.instance;
            const onRobot = jibo.runMode === jibo.RunMode.ON_ROBOT || jibo.runMode === jibo.RunMode.REMOTELY || jibo.runMode === jibo.RunMode.UNIT_TESTS;
            if (mimConfig.timeout > 0 && (onRobot || ignoreSimulator)) {
                listen.timeout = mimConfig.timeout * 1000;
            }
            window.addEventListener('touchstart', this.resetTimeout);
            window.addEventListener('touchmove', this.resetTimeout);
            window.addEventListener('mousedown', this.resetTimeout);
            window.addEventListener('mousemove', this.resetTimeout);
            const currentView = this.activeView || jibo.face.views.currentView;
            const shouldListen = !MimManager_1.default.instance.silentMenus ||
                mimConfig.mimType !== MimConfig_1.MimTypes.OPTIONAL_RESPONSE ||
                !currentView || currentView.category !== View_1.CATEGORY.GUI;
            if (shouldListen) {
                const listenDelegate = MimManager_1.default.instance.listenDelegate;
                if (resetTimeout) {
                    if (currentView && currentView.category === View_1.CATEGORY.GUI) {
                        listenDelegate.enterActiveMode(jibo_embodied_dialog_1.listen.ActiveListenMode.UI);
                    }
                    else {
                        switch (mimConfig.activeListenMode) {
                            case jibo_embodied_dialog_1.listen.ActiveListenMode.OPTIONAL_RESPONSE:
                                listenDelegate.enterActiveMode(jibo_embodied_dialog_1.listen.ActiveListenMode.OPTIONAL_RESPONSE, { timeout: listen.timeout });
                                break;
                            case jibo_embodied_dialog_1.listen.ActiveListenMode.UI:
                                listenDelegate.enterActiveMode(jibo_embodied_dialog_1.listen.ActiveListenMode.UI);
                                break;
                            case jibo_embodied_dialog_1.listen.AmbientListenMode.NO_BODY:
                                listenDelegate.setAmbientMode(jibo_embodied_dialog_1.listen.AmbientListenMode.NO_BODY);
                                break;
                        }
                    }
                }
                this.asrMetadata.mimState = this.mimState.lastResultState;
                this.asrMetadata.noMatches = this.mimState.noMatchCount;
                this.asrMetadata.noInputs = this.mimState.noInputCount;
                const jibo = Runtime_1.default.instance;
                jibo.performance.log('MimListenStart', 'Creating a listener');
                jibo.autobot.log('MimListenStart', 'Creating a listener');
                const rules = mimConfig.ruleNames.slice();
                rules.push(GUI_RULE);
                if (this.entryPrompt.text) {
                    rules.push(REPEAT_RULE);
                }
                if (mimConfig.thanksHandling !== MimConfig_1.ThanksOptions.IGNORE) {
                    rules.push(THANKS_RULE);
                }
                let hint_phrases = [];
                let fast_eos_array = [];
                if (this.mimConfig.hintPhrases) {
                    const phrases = this.mimConfig.runSandboxed('`' + this.mimConfig.hintPhrases + '`', this.promptData).split(',');
                    for (let phrase of phrases) {
                        hint_phrases.push(phrase.trim());
                    }
                }
                if (this.mimConfig.fastEosArray) {
                    const phrases = this.mimConfig.runSandboxed('`' + this.mimConfig.fastEosArray + '`', this.promptData).split(',');
                    for (let phrase of phrases) {
                        fast_eos_array.push(phrase.trim());
                    }
                }
                const listenOptions = {
                    nluRules: rules,
                    log: this.asrMetadata,
                    hintPhrases: hint_phrases,
                    earlyEOS: fast_eos_array,
                    sosTimeout: this.mimConfig.timeout - (Date.now() - listen.startTime) / 1000
                };
                try {
                    const listener = yield listenDelegate.create(listenOptions);
                    if (this.status !== Status_1.default.IN_PROGRESS) {
                        return;
                    }
                    if (this.mimMachine.current !== this.states.listen) {
                        listener.stop();
                        return;
                    }
                    listen.listener = listener;
                    listen.failedToGetListener = false;
                    listen.listener.on(ListenEvent_1.default.FINISHED, () => {
                        if (this.status !== Status_1.default.IN_PROGRESS) {
                            return;
                        }
                        listen.listener = null;
                        if (this.mimMachine.current === this.states.listen) {
                            if (!this.asrResults) {
                                this.asrResults = new jetstream_client_1.types.ListenResult(null);
                            }
                            if (this.checkResult) {
                                this.checkResult(this.asrResults);
                            }
                            if (this.asrResults.state === jetstream_client_1.types.ListenResultState.noInput && Date.now() - listen.startTime < listen.timeout) {
                                this.states.listen.transitionTo(this.states.restartListen);
                            }
                            else if (this.asrResults.entities.domain === 'mim_global') {
                                this.states.listen.transitionTo(this.states.analyzeMimGlobal);
                            }
                            else if (this.asrResults && (this.asrResults.entities.domain === 'gui_command' ||
                                this.asrResults.entities.domain === 'menu_global')) {
                                this.states.listen.transitionTo(this.states.analyzeMenuGlobal);
                            }
                            else {
                                this.states.listen.transitionTo(this.states.analyzeResults, this.asrResults.state === jetstream_client_1.types.ListenResultState.noInput);
                            }
                        }
                    });
                    listen.listener.on(ListenEvent_1.default.CLOUD, (asrResultsData) => {
                        this.asrResults = asrResultsData.result;
                        this.exitInputType = analytics.INPUT.SPEECH;
                    });
                    listen.listener.on(ListenEvent_1.default.INTERRUPTED, () => {
                        if (this.status !== Status_1.default.IN_PROGRESS ||
                            this.mimMachine.current !== this.states.listen) {
                            return;
                        }
                        listenDelegate.exitActiveMode();
                        this.states.listen.transitionTo(this.states.waitForHJEnd);
                    });
                }
                catch (err) {
                    if (this.status !== Status_1.default.IN_PROGRESS ||
                        this.mimMachine.current !== this.states.listen) {
                        return;
                    }
                    if (listen.failedToGetListener) {
                        log.error('Failed to get a listener a second time. Exiting skill');
                        Runtime_1.default.instance.lifecycle.finished();
                    }
                    else {
                        log.warn('Failed to get a listener. Trying again');
                        listen.failedToGetListener = true;
                        this.startListen(transition, resetTimeout);
                    }
                    return;
                }
            }
            else {
                log.debug('Skipping listener creation because silentMenus is true');
            }
        });
    }
    resetTimeout() {
        if (this.listen) {
            this.listen.startTime = Date.now();
        }
    }
    stopListen() {
        this.listenExit();
    }
    listenExit(transition) {
        if (this.listen && this.listen.listener) {
            const cancelTurn = !transition || (transition.getDestinationState() !== this.states.parseSpoof);
            this.listen.listener.stop(cancelTurn);
            this.listen.listener = null;
        }
        window.removeEventListener('touchstart', this.resetTimeout);
        window.removeEventListener('touchmove', this.resetTimeout);
        window.removeEventListener('mousedown', this.resetTimeout);
        window.removeEventListener('mousemove', this.resetTimeout);
    }
    updateListen() {
        const listen = this.listen;
        if (listen && !listen.listener && listen.timeout &&
            Date.now() - listen.startTime >= listen.timeout) {
            this.asrResults = new jetstream_client_1.types.ListenResult(null);
            if (this.checkResult) {
                this.checkResult(this.asrResults);
            }
            this.states.listen.transitionTo(this.states.analyzeResults, true);
        }
    }
    analyzeMimGlobal(transition, result) {
        const intent = this.asrResults.intent;
        if (intent === 'repeat' && this.entryPrompt.text) {
            this.mimState.lastResultState = MimState_1.States.REPEAT;
            this.repeatCount++;
            this.states.analyzeMimGlobal.transitionTo(this.states.choosePrompt);
            analytics.nonEndingResult(this.analyticsBase, this.exitInputType, intent, this.asrResults.text, this.asrResults.entities.domain, this.lastPromptId);
            return;
        }
        if (intent === 'thanks' && this.mimConfig.thanksHandling !== MimConfig_1.ThanksOptions.IGNORE) {
            this.mimState.lastResultState = MimState_1.States.THANKS;
            this.states.analyzeMimGlobal.transitionTo(this.states.choosePrompt);
            analytics.nonEndingResult(this.analyticsBase, this.exitInputType, intent, this.asrResults.text, this.asrResults.entities.domain, this.lastPromptId);
            return;
        }
        analytics.nonEndingIgnored(this.analyticsBase, this.exitInputType, intent, this.asrResults.text, this.asrResults.entities.domain, this.lastPromptId);
        this.asrResults.nlu = null;
        this.states.analyzeMimGlobal.transitionTo(this.states.analyzeResults);
    }
    analyzeMenuGlobal(transition, result) {
        const handled = Runtime_1.default.instance.face.views.actionEnactor(new ActionData_1.default(ActionData_1.default.VERBAL_COMMAND, this.asrResults));
        if (handled) {
            analytics.nonEndingResult(this.analyticsBase, this.exitInputType, this.asrResults.intent, this.asrResults.text, this.asrResults.entities.domain, this.lastPromptId);
            if (this.mimMachine.current === this.states.analyzeMenuGlobal) {
                this.states.analyzeMenuGlobal.transitionTo(this.states.listen, true);
            }
            return;
        }
        analytics.nonEndingIgnored(this.analyticsBase, this.exitInputType, this.asrResults.intent, this.asrResults.text, this.asrResults.entities.domain, this.lastPromptId);
        this.asrResults.nlu = null;
        this.states.analyzeMenuGlobal.transitionTo(this.states.analyzeResults);
    }
    parseSpoofedUtterance(transition, result) {
        const listenDelegate = MimManager_1.default.instance.listenDelegate;
        listenDelegate.exitActiveMode();
        MimManager_1.default.instance.shouldShowGUI = true;
        this.exitInputType = analytics.INPUT.TOUCH;
        log.debug(`Screen Tapped - ${this.loggingLead} MIM total errors[${this.mimState.errors}] LastResultState[${this.mimState.lastResultState}]`);
        Runtime_1.default.instance.performance.log('MimManualParseStart', 'Starting a manual NLU parse because a GUI event is spoofing an answer');
        this.asrResults = new jetstream_client_1.types.ListenResult({
            text: '',
            confidence: 1
        }, result);
        if (this.checkResult) {
            this.checkResult(this.asrResults);
        }
        this.states.parseSpoof.transitionTo(this.states.analyzeResults);
    }
    analyzeResults(transition, timedOut) {
        const mimState = this.mimState;
        const mimConfig = this.mimConfig;
        if (timedOut || !this.asrResults) {
            mimState.lastResultState = MimState_1.States.NO_INPUT;
            this.exitInputType = analytics.INPUT.SILENCE;
        }
        else {
            mimState.lastResultState = this.asrResults.state;
            log.debug(`MIM Listen results - ${this.loggingLead} Last Prompt Id[${this.lastPromptId}] NLU Results[intent:${this.asrResults.intent}, ${JSON.stringify(this.asrResults.entities)}]`);
        }
        const listenDelegate = MimManager_1.default.instance.listenDelegate;
        if (mimConfig.mimType === MimConfig_1.MimTypes.OPTIONAL_RESPONSE) {
            if (mimConfig.ignoreNoMatch && mimState.lastResultState === MimState_1.States.NO_MATCH) {
                this.states.analyzeResults.transitionTo(this.states.listen, false);
            }
            else {
                mimState.success = true;
                listenDelegate.exitActiveMode();
                this.states.analyzeResults.transitionTo(this.states.reportResults);
            }
            return;
        }
        listenDelegate.exitActiveMode();
        switch (mimState.lastResultState) {
            case MimState_1.States.MATCH:
                mimState.success = true;
                break;
            case MimState_1.States.NO_MATCH:
                mimState.incrementNoMatchCount();
                log.debug(`MIM Listen Error - ${this.loggingLead} No Match Count[${mimState.noMatchCount}]`);
                analytics.noMatch(this.analyticsBase, mimState.noMatchCount, this.lastPromptId, this.asrResults.text);
                if (!mimConfig.hasErrorPrompt(MimState_1.States.NO_MATCH, mimState.noMatchCount)) {
                    mimState.failure = true;
                }
                MimManager_1.default.instance.shouldShowGUI = true;
                break;
            case MimState_1.States.NO_INPUT:
                mimState.incrementNoInputCount();
                log.debug(`MIM Listen Error - ${this.loggingLead} No Input Count[${mimState.noInputCount}]`);
                analytics.noInput(this.analyticsBase, mimState.noInputCount, this.lastPromptId);
                if (!mimConfig.hasErrorPrompt(MimState_1.States.NO_INPUT, mimState.noInputCount)) {
                    mimState.failure = true;
                }
                MimManager_1.default.instance.shouldShowGUI = true;
                break;
        }
        if (mimState.done) {
            this.states.analyzeResults.transitionTo(this.states.reportResults);
        }
        else {
            this.states.analyzeResults.transitionTo(this.states.choosePrompt);
        }
    }
    reportResults(transition, result) {
        this.cleanUpEvents();
        this.viewTransition = {
            remove: true,
            transitionClose: ViewManager_1.TRANSITION.DOWN
        };
        if (this.mimState.failure) {
            let result = false;
            if (this.viewConfig && this.viewConfig.defaultClose) {
                this.viewTransition = this.viewConfig.defaultClose;
            }
            if (this.onFailure) {
                result = this.onFailure({
                    state: this.mimState,
                    asrResults: this.asrResults
                });
            }
            if (!result) {
                const exceptionData = {
                    state: this.mimState.lastResultState,
                    input: this.asrResults ? this.asrResults.text : ''
                };
                this.states.reportResults.transitionTo(this.states.handleException, exceptionData);
                return;
            }
            let exitType;
            let inputType;
            if (this.mimState.lastResultState === MimState_1.States.NO_INPUT) {
                exitType = analytics.EXIT_TYPE.MAX_NI;
                inputType = analytics.INPUT.SILENCE;
            }
            else {
                exitType = analytics.EXIT_TYPE.MAX_NM;
                inputType = analytics.INPUT.SPEECH;
            }
            analytics.end(this.analyticsBase, exitType, inputType, '', this.asrResults ? this.asrResults.text : '', '', this.lastPromptId, this.mimState.noMatchCount, this.mimState.noInputCount);
        }
        else {
            if (this.viewConfig && this.viewConfig.defaultSelect) {
                this.viewTransition = this.viewConfig.defaultSelect;
            }
            if (this.onSuccess) {
                this.onSuccess({
                    state: this.mimState,
                    asrResults: this.asrResults
                });
            }
            let intent = '';
            if (this.mimState.lastResultState !== MimState_1.States.NO_INPUT &&
                this.asrResults && this.asrResults && this.asrResults.intent) {
                intent = this.asrResults.intent;
            }
            if (this.mimConfig.mimType === MimConfig_1.MimTypes.ANNOUNCEMENT) {
                intent = analytics.NONE;
                this.exitInputType = analytics.INPUT.NONE;
            }
            analytics.end(this.analyticsBase, analytics.EXIT_TYPE.SUCCESS, this.exitInputType, intent, this.asrResults ? this.asrResults.text : '', '', this.lastPromptId, this.mimState.noMatchCount, this.mimState.noInputCount);
        }
        this.unloadRules();
        this.removeView();
        if (this.destroyViewPromise) {
            Runtime_1.default.instance.performance.log('MimEndViewRemovalStart', 'Waiting for the Mim GUI to be cleaned up before ending the Mim');
            this.destroyViewPromise.then(() => {
                if (this.status !== Status_1.default.IN_PROGRESS) {
                    return;
                }
                Runtime_1.default.instance.performance.log('MimEndViewRemovalEnd');
                this.status = Status_1.default.SUCCEEDED;
            });
        }
        else {
            this.status = Status_1.default.SUCCEEDED;
        }
    }
    handleException(transition, result) {
        const state = result.state;
        if (state === MimState_1.States.NO_INPUT) {
            this.exceptionFlow = Runtime_1.default.instance.flow.create(NoInputException, {
                assetPack: 'core://',
                blackboard: {
                    speechDelegate: MimManager_1.default.instance.speakDelegate
                }
            });
        }
        else if (state === MimState_1.States.NO_MATCH) {
            this.exceptionFlow = Runtime_1.default.instance.flow.create(NoMatchException, {
                assetPack: 'core://',
                blackboard: {
                    showInputText: this.showInputText.bind(this, result.input),
                    hideInputText: this.hideInputText.bind(this),
                    speechDelegate: MimManager_1.default.instance.speakDelegate
                }
            });
        }
        else if (state === MimState_1.States.MENU_CLOSED) {
            Runtime_1.default.instance.lifecycle.finished();
        }
    }
    updateException() {
        if (this.exceptionFlow && this.exceptionFlow.update()) {
            const result = this.exceptionFlow.result.transition;
            this.exceptionFlow.destroy();
            this.exceptionFlow = null;
            if (result === 'exit') {
                Runtime_1.default.instance.lifecycle.finished();
            }
            else if (result === 'restart') {
                analytics.recoveredException(this.analyticsBase);
                this.mimState.reset();
                this.mimState.lastResultState = MimState_1.States.HOLD_RETURN;
                this.states.handleException.transitionTo(this.states.choosePrompt);
            }
        }
    }
    stopException() {
        if (this.exceptionFlow) {
            this.exceptionFlow.destroy();
            this.exceptionFlow = null;
        }
        this.hideInputText();
    }
    showInputText(notMatchedText) {
        const viewConfig = {
            viewConfig: {
                type: "View",
                id: "mim_not_matched_text"
            },
            componentConfigs: [
                {
                    id: "title",
                    type: "Label",
                    text: notMatchedText,
                    style: {
                        fontSize: "100",
                        fontFamily: "Proxima Nova Soft",
                        fontStyle: "bold",
                        fill: "#FFFFFF",
                        wordWrap: true,
                        wordWrapWidth: 1240,
                        align: 'center'
                    },
                    position: {
                        x: FaceRenderer_1.default.WIDTH / 2,
                        y: FaceRenderer_1.default.HEIGHT / 2
                    },
                    targetAnchor: {
                        x: 0.5,
                        y: 0.5
                    }
                }
            ]
        };
        if (this.destroyViewPromise) {
            this.destroyViewPromise.then(() => {
                if (this.status !== Status_1.default.IN_PROGRESS) {
                    return;
                }
                this.activeView = Runtime_1.default.instance.face.views.createView("View", viewConfig, true);
            });
        }
        else {
            this.activeView = Runtime_1.default.instance.face.views.createView("View", viewConfig, true);
        }
        this.viewTransition = {
            remove: true,
            transitionClose: ViewManager_1.TRANSITION.DOWN
        };
    }
    hideInputText() {
        this.removeView();
    }
    waitForHJEnd(transition, result) {
        MimManager_1.default.instance.heyJiboComplete.on(this.recoverFromHJ);
    }
    recoverFromHJ(reason) {
        if (this.lastPromptId) {
            this.mimState.lastResultState = MimState_1.States.HOLD_RETURN;
        }
        if (this.queuedState) {
            const queuedState = this.queuedState;
            this.queuedState = null;
            this.states.waitForHJEnd.transitionTo(queuedState.state, queuedState.data);
        }
        else if (this.isMenu) {
            this.states.waitForHJEnd.transitionTo(this.states.listen, false);
        }
        else {
            this.states.waitForHJEnd.transitionTo(this.states.choosePrompt);
        }
    }
    hjEnded() {
        MimManager_1.default.instance.heyJiboComplete.off(this.recoverFromHJ);
    }
}
exports.default = Mim;

},{"../../Runtime":1,"../../rendering/FaceRenderer":99,"../../rendering/gui/ViewManager":127,"../../rendering/gui/actions/ActionData":130,"../../rendering/gui/views/EyeView":151,"../../rendering/gui/views/MenuView":153,"../../rendering/gui/views/View":156,"../Behavior":3,"../Status":10,"../mim/GenerateListConfig":50,"../mim/MimConfig":51,"../mim/MimManager":52,"../mim/MimState":55,"../mim/analytics/MimAnalytics":58,"../mim/delegates/ListenEvent":60,"../mim/flows/NoInputException":61,"../mim/flows/NoMatchException":62,"./log":32,"@jibo/jetstream-client":undefined,"fs":undefined,"jibo-embodied-dialog":undefined,"jibo-plugins":undefined,"jibo-state-machine":undefined,"uuid":undefined}],17:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Behavior_1 = require("../Behavior");
const Status_1 = require("../Status");
class Null extends Behavior_1.default {
    update() {
        return Status_1.default.IN_PROGRESS;
    }
}
exports.default = Null;

},{"../Behavior":3,"../Status":10}],18:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const ParentBehavior_1 = require("../ParentBehavior");
const Status_1 = require("../Status");
class Parallel extends ParentBehavior_1.default {
    constructor(options) {
        super(options);
        this.runChildren = null;
        this.activeChildren = 0;
        this.childStops = [];
        this.stopping = false;
    }
    destroy() {
        super.destroy();
        this.runChildren = null;
        this.childStops = null;
    }
    start() {
        if (this.children.length === 0) {
            return false;
        }
        let oneFailedToStart = false;
        this.runChildren = [];
        for (let i = 0; i < this.children.length; i++) {
            const child = this.children[i];
            if (child._start()) {
                this.runChildren.push(child);
            }
            else {
                oneFailedToStart = true;
            }
        }
        this.activeChildren = this.runChildren.length;
        if (oneFailedToStart) {
            for (let i = 0; i < this.runChildren.length; i++) {
                this.runChildren[i]._stop();
            }
            return false;
        }
        return true;
    }
    stop() {
        for (let i = 0; i < this.runChildren.length; i++) {
            if (!this.runChildren[i]) {
                continue;
            }
            this.childStops.push(this.runChildren[i]._stop());
        }
        if (this.childStops.length === 0) {
            return Promise.resolve();
        }
        return Promise.all(this.childStops);
    }
    update() {
        if (this.stopping) {
            return Status_1.default.IN_PROGRESS;
        }
        let oneFailed = false;
        for (let i = 0; i < this.runChildren.length; i++) {
            if (!this.runChildren[i]) {
                continue;
            }
            const child = this.runChildren[i];
            const status = child._update();
            if (status === Status_1.default.SUCCEEDED) {
                if (this.options.succeedOnOne) {
                    this.stopping = true;
                    this._stop().then(() => {
                        this._currentStatus = Status_1.default.SUCCEEDED;
                        this.stopping = false;
                    });
                    this._currentStatus = Status_1.default.IN_PROGRESS;
                    return Status_1.default.IN_PROGRESS;
                }
                else {
                    this.childStops.push(child._stop());
                    this.runChildren[i] = null;
                    this.activeChildren--;
                }
            }
            else if (status === Status_1.default.FAILED) {
                oneFailed = true;
            }
            else if (status === Status_1.default.PAUSED) {
                return Status_1.default.IN_PROGRESS;
            }
        }
        if (oneFailed) {
            return Status_1.default.FAILED;
        }
        else if (this.activeChildren === 0) {
            return Status_1.default.SUCCEEDED;
        }
        else {
            return Status_1.default.IN_PROGRESS;
        }
    }
}
exports.default = Parallel;

},{"../ParentBehavior":9,"../Status":10}],19:[function(require,module,exports){
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const Behavior_1 = require("../Behavior");
const Status_1 = require("../Status");
const Runtime_1 = require("../../Runtime");
const jibo_plugins_1 = require("jibo-plugins");
var AnimSelector;
(function (AnimSelector) {
    AnimSelector[AnimSelector["path"] = 1] = "path";
    AnimSelector[AnimSelector["pathFunction"] = 2] = "pathFunction";
    AnimSelector[AnimSelector["name"] = 3] = "name";
    AnimSelector[AnimSelector["query"] = 4] = "query";
    AnimSelector[AnimSelector["nameFunction"] = 5] = "nameFunction";
})(AnimSelector || (AnimSelector = {}));
class MockBuilder {
    constructor() {
        this.options = {};
    }
    setSpeed(speed) {
        this.options.speed = speed;
    }
    setNumLoops(numLoops) {
        this.options.loops = numLoops;
    }
    setDOFs(dofNames) {
        if (dofNames instanceof Array) {
            const dofs = Runtime_1.default.instance.expression.dofs.ALL.createFromDofs(dofNames);
            this.options.dofs = dofs;
        }
        else {
            this.options.dofs = dofNames;
        }
    }
    setLayer(layerName) {
        this.options.layer = layerName;
    }
}
class PlayAnimation extends Behavior_1.default {
    constructor(options) {
        super(options);
        this.stoppedCallbacks = [];
        this.destroyed = false;
        this.status = Status_1.default.INVALID;
        this.animation = null;
        this.instance = null;
        this.onEvent = this.onEvent.bind(this);
        if (typeof this.options.animSelector === 'undefined') {
            this.options.animSelector = AnimSelector.path;
        }
        this.animSelector = this.options.animSelector;
        switch (this.animSelector) {
            case AnimSelector.path:
                this._constructorFromPath(this.options.animPath);
                break;
            case AnimSelector.pathFunction:
                this._constructorFromPath(this.options.animPathFunction());
                break;
            case AnimSelector.name:
                this._constructorFromAnimName(this.options.animName);
                break;
            case AnimSelector.nameFunction:
                this._constructorFromAnimName(this.options.animNameFunction());
                break;
            case AnimSelector.query:
                this._constructorFromAnimQuery();
                break;
        }
    }
    _constructorFromPath(animPath) {
        if (typeof this.options.upload === 'undefined') {
            this.options.upload = true;
        }
        this.alias = jibo_plugins_1.PathUtils.setDefaultPath('animations', animPath);
    }
    _constructorFromAnimName(name) {
        this.anim = Runtime_1.default.instance.animDB.getAnimByName(name);
    }
    _constructorFromAnimQuery() {
        let results = Runtime_1.default.instance.animDB.query(this.options.queryParams());
        this.anim = this.options.queryResultSelector(results);
    }
    start() {
        this.hasBeenReset = false;
        this.status = Status_1.default.IN_PROGRESS;
        if (this.options.config) {
            this.builder = new MockBuilder();
            this.options.config(this.builder);
        }
        const eye = Runtime_1.default.instance.face.eye;
        switch (this.animSelector) {
            case AnimSelector.path:
                eye.holdCurrentAnim();
                this._startFromPath();
                return true;
            case AnimSelector.pathFunction:
                eye.holdCurrentAnim();
                this._startFromPath();
                return true;
            default:
                if (!this.anim) {
                    this.status = Status_1.default.FAILED;
                    return false;
                }
                eye.holdCurrentAnim();
                this._startFromAnimDB();
                return true;
        }
    }
    _startFromPath() {
        return __awaiter(this, void 0, void 0, function* () {
            try {
                const loader = Runtime_1.default.instance.loader;
                const src = jibo_plugins_1.PathUtils.getAssetUri(this.alias, this.assetPack);
                let loadData = {
                    id: this.alias,
                    cache: loader.activeCache,
                    src: src,
                    options: this.builder.options,
                    upload: this.options.upload,
                    root: jibo_plugins_1.PathUtils.findRoot(src),
                    type: 'keys',
                    complete: null
                };
                const data = yield new Promise((resolve, reject) => {
                    loadData.complete = (err, data) => {
                        if (err) {
                            return reject(err);
                        }
                        resolve(data);
                    };
                    const load = loader.load(loadData);
                    this.loadToken = load.tokens[0];
                });
                if (this.status !== Status_1.default.IN_PROGRESS) {
                    loader.unload(this.loadToken);
                    return;
                }
                let animation = yield data.getAnim(this.builder.options);
                if (this.status !== Status_1.default.IN_PROGRESS) {
                    loader.unload(this.loadToken);
                    animation.destroy();
                    return;
                }
                this.onKeysLoaded(animation);
            }
            catch (err) {
                console.error('Could not load animation in PlayAnimation: ', err);
                this.onStopped(Status_1.default.FAILED);
            }
        });
    }
    _startFromAnimDB() {
        return __awaiter(this, void 0, void 0, function* () {
            let opts = this.options.creationOptions();
            if (!opts) {
                opts = {};
            }
            if (!opts.cache) {
                opts.cache = Runtime_1.default.instance.loader.activeCache;
            }
            const playbackResult = this.anim.play(opts, this.options.playbackOptions());
            if (this.status !== Status_1.default.IN_PROGRESS) {
                playbackResult.playback.stop();
            }
            else {
                this.instance = playbackResult.playback;
                try {
                    yield playbackResult.result;
                    this.onStopped(Status_1.default.SUCCEEDED);
                }
                catch (error) {
                    console.error('Error in PlayAnimation when playing from animdb: ', error);
                    this.onStopped(Status_1.default.FAILED);
                }
            }
        });
    }
    update() {
        return this.status;
    }
    stop() {
        if (this.instance) {
            return new Promise((resolve) => {
                this.stoppedCallbacks.push(resolve);
                this.instance.stop();
            });
        }
        else {
            this.reset();
            return Promise.resolve();
        }
    }
    destroy() {
        if (!this.destroyed) {
            this.destroyed = true;
            this.reset();
            super.destroy();
            this.status = null;
            this.stoppedCallbacks = null;
        }
    }
    onKeysLoaded(animation) {
        if (this.status !== Status_1.default.IN_PROGRESS) {
            if (animation) {
                animation.destroy();
            }
            return;
        }
        this.animation = animation;
        Runtime_1.default.instance.face.eye.addAnimation(animation);
        this.animation.instance.events.stopped.on(() => this.onStopped(Status_1.default.SUCCEEDED));
        this.animation.instance.events.cancelled.on(() => this.onStopped(Status_1.default.SUCCEEDED));
        this.animation.instance.events.rejected.on(() => {
            console.warn(`Animation rejected because of dofArbiter priority`);
            this.onStopped(Status_1.default.FAILED);
        });
        this.animation.instance.events.general.on(this.onEvent);
        this.animation.instance.play().catch(error => {
            console.error('Error in PlayAnimation: ', error);
            this.onStopped(Status_1.default.FAILED);
        });
    }
    reset() {
        if (this.hasBeenReset) {
            return;
        }
        if (this.loadToken) {
            this.loadToken.unload();
            this.loadToken = null;
        }
        if (this.animation) {
            Runtime_1.default.instance.face.eye.removeAnimation(this.animation);
            this.animation.removeAllListeners();
        }
        this.animation = null;
        this.instance = null;
        this.hasBeenReset = true;
    }
    onStopped(status) {
        if (!this.destroyed) {
            this.reset();
            this.status = status;
            for (let i = 0; i < this.stoppedCallbacks.length; i++) {
                this.stoppedCallbacks[i]();
            }
            this.stoppedCallbacks = [];
        }
    }
    onEvent(payload) {
        if (!this.destroyed) {
            Runtime_1.default.instance.behaviorEmitter.emit(payload.eventName, payload.payload);
        }
    }
}
exports.default = PlayAnimation;

},{"../../Runtime":1,"../Behavior":3,"../Status":10,"jibo-plugins":undefined}],20:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Behavior_1 = require("../Behavior");
const Status_1 = require("../Status");
const jibo_plugins_1 = require("jibo-plugins");
const Runtime_1 = require("../../Runtime");
class PlayAudio extends Behavior_1.default {
    constructor(options) {
        super(options);
        if (typeof this.options.cache === 'undefined') {
            this.options.cache = true;
        }
        this.status = Status_1.default.INVALID;
        this.alias = this.options.audioPath;
        this.cache = this.options.cache;
        this.sound = null;
        this.token = null;
    }
    start() {
        this.status = Status_1.default.IN_PROGRESS;
        const loader = Runtime_1.default.instance.loader;
        const load = loader.load({
            type: 'sound',
            id: this.alias,
            src: jibo_plugins_1.PathUtils.getAudioUri(this.alias, this.assetPack),
            cache: loader.activeCache,
            complete: this.onLoaded.bind(this)
        });
        this.token = load.tokens[0];
        return true;
    }
    stop() {
        if (this.sound) {
            this.sound.stop();
            this.sound = null;
        }
        if (!this.cache && this.token) {
            this.token.unload();
            this.token = null;
        }
        return Promise.resolve();
    }
    update() {
        return this.status;
    }
    destroy() {
        this.stop();
        if (this.token) {
            this.token.unload();
            this.token = null;
        }
        super.destroy();
        this.status = null;
    }
    onLoaded(err, sound) {
        if (err) {
            throw err;
        }
        if (this.status !== Status_1.default.IN_PROGRESS) {
            if (!this.cache && this.token) {
                this.token.unload();
                this.token = null;
            }
            return;
        }
        this.sound = sound;
        this.sound.play(() => {
            this.stop();
            this.status = Status_1.default.SUCCEEDED;
        });
    }
}
exports.default = PlayAudio;

},{"../../Runtime":1,"../Behavior":3,"../Status":10,"jibo-plugins":undefined}],21:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const ParentBehavior_1 = require("../ParentBehavior");
const Status_1 = require("../Status");
class Random extends ParentBehavior_1.default {
    constructor(options) {
        super(options);
        this.current = -1;
    }
    start() {
        if (this.children.length === 0) {
            return false;
        }
        this.current = Math.round(Math.random() * (this.children.length - 1));
        const success = this.children[this.current]._start();
        this.current = success ? this.current : -1;
        return success;
    }
    stop() {
        let rtn;
        if (this.current !== -1 && this.current < this.children.length) {
            rtn = this.children[this.current]._stop();
            this.current = -1;
        }
        return rtn || Promise.resolve();
    }
    update() {
        const status = this.children[this.current]._update();
        if (status === Status_1.default.PAUSED) {
            return Status_1.default.IN_PROGRESS;
        }
        return status;
    }
}
exports.default = Random;

},{"../ParentBehavior":9,"../Status":10}],22:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Behavior_1 = require("../Behavior");
const Status_1 = require("../Status");
const Runtime_1 = require("../../Runtime");
class ReadBarcode extends Behavior_1.default {
    constructor(options) {
        super(options);
        this.status = Status_1.default.INVALID;
    }
    start() {
        this.status = Status_1.default.IN_PROGRESS;
        Runtime_1.default.instance.lps.readBarcode((error, data) => {
            if (this.status !== Status_1.default.IN_PROGRESS) {
                return;
            }
            this.options.onBarcode(error, data);
            this.status = Status_1.default.SUCCEEDED;
        });
        return true;
    }
    update() {
        return this.status;
    }
    destroy() {
        super.destroy();
        this.status = null;
    }
}
exports.default = ReadBarcode;

},{"../../Runtime":1,"../Behavior":3,"../Status":10}],23:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const ParentBehavior_1 = require("../ParentBehavior");
const Status_1 = require("../Status");
class Sequence extends ParentBehavior_1.default {
    constructor(options) {
        super(options);
        this.current = -1;
    }
    start() {
        if (this.children.length === 0) {
            return true;
        }
        this.current = 0;
        const success = this.children[this.current]._start();
        this.current = success ? this.current : -1;
        return success;
    }
    stop() {
        let rtn;
        if (this.current !== -1 && this.current < this.children.length) {
            rtn = this.children[this.current]._stop();
            this.current = -1;
        }
        return rtn || Promise.resolve();
    }
    update() {
        if (this.children.length === 0) {
            return Status_1.default.SUCCEEDED;
        }
        while (this.current !== -1 && this.current < this.children.length) {
            const childStatus = this.children[this.current]._update();
            if (childStatus === Status_1.default.SUCCEEDED) {
                this.current++;
                if (this.current < this.children.length) {
                    const startSuccess = this.children[this.current]._start();
                    if (!startSuccess) {
                        return Status_1.default.FAILED;
                    }
                }
                else {
                    return Status_1.default.SUCCEEDED;
                }
            }
            else if (childStatus === Status_1.default.IN_PROGRESS || childStatus === Status_1.default.PAUSED) {
                return Status_1.default.IN_PROGRESS;
            }
            else {
                return Status_1.default.FAILED;
            }
        }
        return Status_1.default.SUCCEEDED;
    }
}
exports.default = Sequence;

},{"../ParentBehavior":9,"../Status":10}],24:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Behavior_1 = require("../Behavior");
const Status_1 = require("../Status");
const Runtime_1 = require("../../Runtime");
const jibo_plugins_1 = require("jibo-plugins");
class Subtree extends Behavior_1.default {
    constructor(options) {
        super(options);
        this.status = Status_1.default.INVALID;
        this.root = null;
    }
    set tree(tree) {
        this.options.behaviorPath = () => {
            return tree;
        };
    }
    start() {
        this.status = Status_1.default.IN_PROGRESS;
        let tree;
        if (typeof this.options.behaviorPath === 'function') {
            tree = this.options.behaviorPath();
        }
        else {
            tree = jibo_plugins_1.PathUtils.getAssetUri(this.options.behaviorPath, this.assetPack);
        }
        this.root = Runtime_1.default.instance.bt.create(tree, {
            notepad: this.options.getNotepad(),
            blackboard: this.blackboard,
            assetPack: this.assetPack
        });
        this.status = this.root.start() ? this.status : Status_1.default.FAILED;
        return true;
    }
    stop() {
        if (this.root) {
            return this.root.stop();
        }
        return Promise.resolve();
    }
    update() {
        if (this.status === Status_1.default.FAILED) {
            this.root.destroy();
            this.root = null;
            return this.status;
        }
        if (!this.root) {
            return this.status;
        }
        let status = this.root.update();
        if (status === Status_1.default.SUCCEEDED || status === Status_1.default.FAILED) {
            this.options.onResult(this.root.result);
            this.root.destroy();
            this.root = null;
        }
        return status;
    }
    destroy() {
        super.destroy();
        if (this.root) {
            this.root.destroy();
            this.root = null;
        }
    }
}
exports.default = Subtree;

},{"../../Runtime":1,"../Behavior":3,"../Status":10,"jibo-plugins":undefined}],25:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Behavior_1 = require("../Behavior");
const Subtree_1 = require("./Subtree");
class SubtreeJs extends Behavior_1.default {
    constructor(options) {
        super(options);
        this.subtree = new Subtree_1.default({
            name: this.name,
            getNotepad: options.getNotepad,
            onResult: options.onResult,
            blackboard: this.blackboard,
            emitter: this.emitter,
            assetPack: this.assetPack
        });
    }
    start() {
        this.options.getTree((createTree) => {
            this.subtree.tree = createTree;
            this.subtree._start();
        });
        return true;
    }
    stop() {
        return this.subtree._stop();
    }
    update() {
        return this.subtree._update();
    }
    destroy() {
        super.destroy();
        if (this.subtree) {
            this.subtree.destroy();
            this.subtree = null;
        }
    }
}
exports.default = SubtreeJs;

},{"../Behavior":3,"./Subtree":24}],26:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const ParentBehavior_1 = require("../ParentBehavior");
const Status_1 = require("../Status");
class Switch extends ParentBehavior_1.default {
    constructor(options) {
        super(options);
        this.current = -1;
    }
    start() {
        if (this.children.length === 0) {
            return false;
        }
        this.current = 0;
        return this.findStart();
    }
    findStart() {
        let startOk = false;
        while (!startOk && this.current < this.children.length) {
            startOk = this.children[this.current]._start();
            if (!startOk) {
                this.current++;
            }
        }
        return true;
    }
    stop() {
        let rtn;
        if (this.current !== -1 && this.current < this.children.length) {
            rtn = this.children[this.current]._stop();
            this.current = -1;
        }
        return rtn || Promise.resolve();
    }
    update() {
        if (this.current !== -1 && this.current < this.children.length) {
            const childStatus = this.children[this.current]._update();
            if (childStatus === Status_1.default.FAILED) {
                this.current++;
                if (this.current >= this.children.length || !this.findStart()) {
                    return Status_1.default.SUCCEEDED;
                }
                else {
                    return Status_1.default.IN_PROGRESS;
                }
            }
            else if (childStatus === Status_1.default.PAUSED) {
                return Status_1.default.IN_PROGRESS;
            }
            return childStatus;
        }
        return Status_1.default.SUCCEEDED;
    }
}
exports.default = Switch;

},{"../ParentBehavior":9,"../Status":10}],27:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Behavior_1 = require("../Behavior");
const Status_1 = require("../Status");
const Runtime_1 = require("../../Runtime");
class TakePhoto extends Behavior_1.default {
    constructor(options) {
        super(options, {
            noDistortion: true
        });
        this.status = Status_1.default.INVALID;
    }
    start() {
        this.status = Status_1.default.IN_PROGRESS;
        let params = {
            camera: this.options.camera,
            photoType: this.options.resolution
        };
        Runtime_1.default.instance.media.takePhoto(params, (error, data) => {
            if (this.status !== Status_1.default.IN_PROGRESS) {
                return;
            }
            if (error) {
                this.onPhoto(error, null);
                this.status = Status_1.default.SUCCEEDED;
                return;
            }
            else {
                let imageUrl = Runtime_1.default.instance.media.getPreviewUrl(data.id);
                this.onPhoto(null, imageUrl);
            }
        });
        return true;
    }
    update() {
        return this.status;
    }
    destroy() {
        super.destroy();
        this.status = null;
    }
    onPhoto(error, imageUrl) {
        this.options.onPhoto(error, imageUrl);
        this.status = Status_1.default.SUCCEEDED;
    }
}
exports.default = TakePhoto;

},{"../../Runtime":1,"../Behavior":3,"../Status":10}],28:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Behavior_1 = require("../Behavior");
const Status_1 = require("../Status");
const Runtime_1 = require("../../Runtime");
class TextToSpeech extends Behavior_1.default {
    constructor(options) {
        super(options);
        this.onSpeakingStopped = this.onSpeakingStopped.bind(this);
        this.status = Status_1.default.INVALID;
    }
    start() {
        const tts = Runtime_1.default.instance.tts;
        this.status = Status_1.default.IN_PROGRESS;
        tts.speak(this.options.words, (err) => {
            this.status = Status_1.default.SUCCEEDED;
            if (err) {
                console.log("tts.speak() error: " + err);
            }
        });
        this.cleanup();
        tts.word.on(this.options.onWord);
        tts.stopped.on(this.onSpeakingStopped);
        return true;
    }
    stop() {
        this.cleanup();
        return Promise.resolve();
    }
    update() {
        if (this.status !== Status_1.default.IN_PROGRESS) {
            this.cleanup();
        }
        return this.status;
    }
    destroy() {
        super.destroy();
        this.status = null;
    }
    set words(words) {
        this.options.words = words;
    }
    onSpeakingStopped() {
        this.status = Status_1.default.SUCCEEDED;
    }
    cleanup() {
        const tts = Runtime_1.default.instance.tts;
        tts.stopped.off(this.onSpeakingStopped);
        tts.word.off(this.options.onWord);
    }
}
exports.default = TextToSpeech;

},{"../../Runtime":1,"../Behavior":3,"../Status":10}],29:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Behavior_1 = require("../Behavior");
const TextToSpeech_1 = require("./TextToSpeech");
class TextToSpeechJs extends Behavior_1.default {
    constructor(options) {
        super(options);
        this.behavior = new TextToSpeech_1.default({
            emitter: this.emitter,
            blackboard: this.blackboard,
            onWord: this.options.onWord,
            assetPack: this.assetPack
        });
    }
    start() {
        this.options.getWords((words) => {
            this.behavior.words = words;
            this.behavior._start();
        });
        return true;
    }
    stop() {
        return this.behavior._stop();
    }
    update() {
        return this.behavior._update();
    }
    destroy() {
        super.destroy();
        if (this.behavior) {
            this.behavior.destroy();
            this.behavior = null;
        }
    }
}
exports.default = TextToSpeechJs;

},{"../Behavior":3,"./TextToSpeech":28}],30:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Behavior_1 = require("../Behavior");
const Status_1 = require("../Status");
const Null_1 = require("./Null");
const TimeoutSucceedJs_1 = require("../decorators/TimeoutSucceedJs");
class TimeoutJs extends Behavior_1.default {
    constructor(options) {
        super(options);
        let decorator = new TimeoutSucceedJs_1.default({
            getTime: options.getTime
        });
        this.behavior = new Null_1.default({
            decorators: [decorator]
        });
        this.status = Status_1.default.INVALID;
    }
    start() {
        this.status = Status_1.default.IN_PROGRESS;
        return this.behavior._start();
    }
    stop() {
        return this.behavior._stop();
    }
    update() {
        this.status = this.behavior._update();
        return this.status;
    }
    destroy() {
        super.destroy();
        if (this.behavior) {
            this.behavior.destroy();
            this.behavior = null;
        }
    }
}
exports.default = TimeoutJs;

},{"../Behavior":3,"../Status":10,"../decorators/TimeoutSucceedJs":45,"./Null":17}],31:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Blink_1 = require("./Blink");
const ExecuteScript_1 = require("./ExecuteScript");
const ExecuteScriptAsync_1 = require("./ExecuteScriptAsync");
const LookAt_1 = require("./LookAt");
const Mim_1 = require("./Mim");
const Menu_1 = require("./Menu");
const Null_1 = require("./Null");
const Parallel_1 = require("./Parallel");
const PlayAnimation_1 = require("./PlayAnimation");
const PlayAudio_1 = require("./PlayAudio");
const Random_1 = require("./Random");
const ReadBarcode_1 = require("./ReadBarcode");
const Sequence_1 = require("./Sequence");
const Subtree_1 = require("./Subtree");
const SubtreeJs_1 = require("./SubtreeJs");
const Switch_1 = require("./Switch");
const TakePhoto_1 = require("./TakePhoto");
const TextToSpeech_1 = require("./TextToSpeech");
const TextToSpeechJs_1 = require("./TextToSpeechJs");
const TimeoutJs_1 = require("./TimeoutJs");
exports.default = {
    Blink: Blink_1.default,
    ExecuteScript: ExecuteScript_1.default,
    ExecuteScriptAsync: ExecuteScriptAsync_1.default,
    LookAt: LookAt_1.default,
    Mim: Mim_1.default,
    Menu: Menu_1.default,
    Null: Null_1.default,
    Parallel: Parallel_1.default,
    PlayAnimation: PlayAnimation_1.default,
    PlayAudio: PlayAudio_1.default,
    Random: Random_1.default,
    ReadBarcode: ReadBarcode_1.default,
    Sequence: Sequence_1.default,
    Subtree: Subtree_1.default,
    SubtreeJs: SubtreeJs_1.default,
    Switch: Switch_1.default,
    TakePhoto: TakePhoto_1.default,
    TextToSpeech: TextToSpeech_1.default,
    TextToSpeechJs: TextToSpeechJs_1.default,
    TimeoutJs: TimeoutJs_1.default
};

},{"./Blink":11,"./ExecuteScript":12,"./ExecuteScriptAsync":13,"./LookAt":14,"./Menu":15,"./Mim":16,"./Null":17,"./Parallel":18,"./PlayAnimation":19,"./PlayAudio":20,"./Random":21,"./ReadBarcode":22,"./Sequence":23,"./Subtree":24,"./SubtreeJs":25,"./Switch":26,"./TakePhoto":27,"./TextToSpeech":28,"./TextToSpeechJs":29,"./TimeoutJs":30}],32:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log_1 = require("../log");
exports.default = log_1.default.createChild('Behaviors');

},{"../log":49}],33:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Decorator_1 = require("../Decorator");
class Case extends Decorator_1.default {
    start() {
        return this.options.conditional();
    }
    update(result) {
        return result;
    }
}
exports.default = Case;

},{"../Decorator":7}],34:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Decorator_1 = require("../Decorator");
const Status_1 = require("../Status");
class FailOnCondition extends Decorator_1.default {
    constructor(options) {
        super(options, {
            init: function () { }
        });
    }
    start() {
        this.options.init();
        if (this.options.conditional()) {
            return false;
        }
        return true;
    }
    update(result) {
        if (this.options.conditional()) {
            return Status_1.default.FAILED;
        }
        return result;
    }
}
exports.default = FailOnCondition;

},{"../Decorator":7,"../Status":10}],35:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Decorator_1 = require("../Decorator");
const Status_1 = require("../Status");
const Runtime_1 = require("../../Runtime");
class StartOnAnimEvent extends Decorator_1.default {
    constructor(options) {
        super(options);
        this.didStart = false;
        this._onEvent = this._onEvent.bind(this);
    }
    start() {
        this.didStart = false;
        if (this.options.eventName.length !== 0) {
            Runtime_1.default.instance.behaviorEmitter.on(this.options.eventName, this._onEvent);
        }
        return Status_1.default.WAIT;
    }
    stop() {
        if (this.options.eventName.length !== 0) {
            Runtime_1.default.instance.behaviorEmitter.removeListener(this.options.eventName, this._onEvent);
        }
        return Promise.resolve();
    }
    update(result) {
        if (this.didStart) {
            return result;
        }
        else {
            return Status_1.default.WAIT;
        }
    }
    destroy() {
        super.destroy();
        this._onEvent = null;
    }
    _onEvent(animInstance, payload) {
        if (this.options.onReceived) {
            this.options.onReceived(animInstance, payload);
        }
        this.didStart = true;
        Runtime_1.default.instance.behaviorEmitter.removeListener(this.options.eventName, this._onEvent);
    }
}
exports.default = StartOnAnimEvent;

},{"../../Runtime":1,"../Decorator":7,"../Status":10}],36:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Decorator_1 = require("../Decorator");
const Status_1 = require("../Status");
class StartOnCondition extends Decorator_1.default {
    constructor(options) {
        super(options, {
            init: function () { }
        });
        this.didStart = false;
    }
    start() {
        this.options.init();
        this.didStart = false;
        if (this.options.conditional()) {
            this.didStart = true;
            return true;
        }
        else {
            return Status_1.default.WAIT;
        }
    }
    update(result) {
        if (this.didStart) {
            return result;
        }
        else if (this.options.conditional()) {
            this.didStart = true;
            return result;
        }
        else {
            return Status_1.default.WAIT;
        }
    }
}
exports.default = StartOnCondition;

},{"../Decorator":7,"../Status":10}],37:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Decorator_1 = require("../Decorator");
const Status_1 = require("../Status");
class StartOnEvent extends Decorator_1.default {
    constructor(options) {
        super(options);
        this._onEvent = this._onEvent.bind(this);
    }
    start() {
        this.emitter.once(this.options.eventName, this._onEvent);
        this.didStart = false;
        return Status_1.default.WAIT;
    }
    stop() {
        this.emitter.removeListener(this.options.eventName, this._onEvent);
        return Promise.resolve();
    }
    update(result) {
        if (this.didStart) {
            return result;
        }
        else {
            return Status_1.default.WAIT;
        }
    }
    destroy() {
        super.destroy();
        this._onEvent = null;
    }
    _onEvent() {
        this.options.onEvent.apply(null, arguments);
        this.didStart = true;
    }
}
exports.default = StartOnEvent;

},{"../Decorator":7,"../Status":10}],38:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Decorator_1 = require("../Decorator");
const Status_1 = require("../Status");
class SucceedOnCondition extends Decorator_1.default {
    constructor(options) {
        super(options, {
            init: function () { }
        });
    }
    start() {
        this.options.init();
        return true;
    }
    update(result) {
        if (this.options.conditional()) {
            return Status_1.default.SUCCEEDED;
        }
        return result;
    }
}
exports.default = SucceedOnCondition;

},{"../Decorator":7,"../Status":10}],39:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Decorator_1 = require("../Decorator");
const Status_1 = require("../Status");
const events_1 = require("events");
const Runtime_1 = require("../../Runtime");
class SucceedOnEmbedded extends Decorator_1.default {
    constructor(options) {
        super(options);
        this.status = Status_1.default.INVALID;
        this._onHeyJibo = this.onHeyJibo.bind(this);
    }
    start() {
        this.emitter = new events_1.EventEmitter();
        this.status = Status_1.default.IN_PROGRESS;
        Runtime_1.default.instance.jetstream.events.hjHeard.on(this._onHeyJibo);
        this.options.onResult(this.emitter);
        this.status = Status_1.default.IN_PROGRESS;
        return true;
    }
    stop() {
        this.emitter.removeAllListeners();
        Runtime_1.default.instance.jetstream.events.hjHeard.off(this._onHeyJibo);
        return Promise.resolve();
    }
    update(result) {
        if (this.status === Status_1.default.IN_PROGRESS) {
            return result;
        }
        else {
            return this.status;
        }
    }
    destroy() {
        this.stop();
        this._onHeyJibo = null;
        super.destroy();
    }
    onHeyJibo(data) {
        this.emitter.emit('hey-jibo');
        this.emitter.removeAllListeners();
        this.status = Status_1.default.SUCCEEDED;
        Runtime_1.default.instance.jetstream.events.hjHeard.off(this._onHeyJibo);
    }
}
SucceedOnEmbedded.RULES = {
    HEY_jibo: "hey_jibo"
};
exports.default = SucceedOnEmbedded;

},{"../../Runtime":1,"../Decorator":7,"../Status":10,"events":undefined}],40:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Decorator_1 = require("../Decorator");
const Status_1 = require("../Status");
class SucceedOnEvent extends Decorator_1.default {
    constructor(options) {
        super(options);
        this._onEvent = this._onEvent.bind(this);
        this.status = Status_1.default.INVALID;
    }
    start() {
        this.emitter.once(this.options.eventName, this._onEvent);
        this.status = Status_1.default.IN_PROGRESS;
        return true;
    }
    stop() {
        this.emitter.removeListener(this.options.eventName, this._onEvent);
        return Promise.resolve();
    }
    update(result) {
        if (this.status === Status_1.default.SUCCEEDED) {
            return Status_1.default.SUCCEEDED;
        }
        return result;
    }
    destroy() {
        super.destroy();
        this._onEvent = null;
    }
    _onEvent() {
        this.options.onEvent.apply(null, arguments);
        this.status = Status_1.default.SUCCEEDED;
    }
}
exports.default = SucceedOnEvent;

},{"../Decorator":7,"../Status":10}],41:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Decorator_1 = require("../Decorator");
const Status_1 = require("../Status");
const SucceedOnListenJs_1 = require("./SucceedOnListenJs");
const jibo_plugins_1 = require("jibo-plugins");
const fs = require("fs");
const path = require("path");
class SucceedOnListen extends Decorator_1.default {
    constructor(options) {
        super(options);
        this.status = Status_1.default.INVALID;
        this.options.rule = options.rule;
        if (!/\brules[\/\\]/.test(this.options.rule)) {
            this.options.rule = jibo_plugins_1.PathUtils.setDefaultPath('rules', options.rule);
        }
        this.decorator = null;
    }
    start() {
        this.status = Status_1.default.IN_PROGRESS;
        let getRule = (callback) => {
            let uri = jibo_plugins_1.PathUtils.getAssetUri(this.options.rule, this.assetPack);
            if (path.extname(uri) === '.fst') {
                callback(uri);
            }
            else {
                fs.readFile(uri, 'utf8', (err, data) => {
                    if (err) {
                        console.error('Rule file does not exist: ' + uri);
                    }
                    callback(data);
                });
            }
        };
        this.decorator = new SucceedOnListenJs_1.default({
            getOptions: this.options.getOptions,
            getRule: getRule,
            onResult: this.options.onResult,
            emitter: this.emitter,
            blackboard: this.blackboard,
            assetPack: this.assetPack
        });
        return this.decorator._start();
    }
    stop() {
        if (this.decorator) {
            return this.decorator._stop();
        }
        return Promise.resolve();
    }
    update(result) {
        if (this.decorator) {
            let status = this.decorator._update(result);
            return status;
        }
        return this.status;
    }
    destroy() {
        super.destroy();
        if (this.decorator) {
            this.decorator.destroy();
            this.decorator = null;
        }
    }
}
exports.default = SucceedOnListen;

},{"../Decorator":7,"../Status":10,"./SucceedOnListenJs":42,"fs":undefined,"jibo-plugins":undefined,"path":undefined}],42:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Decorator_1 = require("../Decorator");
const Status_1 = require("../Status");
const Runtime_1 = require("../../Runtime");
const jetstream_client_1 = require("@jibo/jetstream-client");
const events_1 = require("events");
var InternalState;
(function (InternalState) {
    InternalState[InternalState["STOPPED"] = 0] = "STOPPED";
    InternalState[InternalState["STARTING"] = 1] = "STARTING";
    InternalState[InternalState["STARTED"] = 2] = "STARTED";
    InternalState[InternalState["UNINITIALIZED"] = 3] = "UNINITIALIZED";
})(InternalState || (InternalState = {}));
class SucceedOnListenJs extends Decorator_1.default {
    constructor(options) {
        super(options, {});
        this._internalState = InternalState.UNINITIALIZED;
        this.getOptions = options.getOptions;
        this.getRulePath = options.getRulePath;
        this.onResult = options.onResult;
        this.listener = null;
    }
    _start() {
        this._internalState = InternalState.STARTING;
        this.status = Status_1.default.IN_PROGRESS;
        this.options.getRule((ruleText) => {
            if (this.status !== Status_1.default.IN_PROGRESS) {
                return;
            }
            if (this._internalState === InternalState.STARTING) {
                let emitter = new events_1.EventEmitter();
                const listenOptions = {
                    nluRules: []
                };
                Runtime_1.default.instance.jetstream.startLocalTurn(listenOptions).then((request) => {
                    if (this.status !== Status_1.default.IN_PROGRESS) {
                        request.cancel();
                        return;
                    }
                    this.listener = request;
                    this.listener.events.on((event) => {
                        switch (event.type) {
                            case jetstream_client_1.types.ServiceEventType.TURN_RESULT:
                                const data = event.data;
                                this._stopInternal();
                                if (data.status === jetstream_client_1.types.TurnResultType.SUCCEEDED) {
                                    emitter.emit('cloud', data.result.nlu);
                                }
                                else if (data.status === jetstream_client_1.types.TurnResultType.INTERRUPTED) {
                                    emitter.emit('interrupted');
                                }
                                break;
                            case jetstream_client_1.types.ServiceEventType.SOS:
                                emitter.emit('speech-start');
                                break;
                            case jetstream_client_1.types.ServiceEventType.EOS:
                                emitter.emit('speech-end');
                                break;
                            case jetstream_client_1.types.ServiceEventType.SPEAKER_ID:
                                emitter.emit('speaker-id', event.data);
                                break;
                        }
                    });
                });
                this.onResult(emitter);
                this._internalState = InternalState.STARTED;
            }
        });
        return true;
    }
    _stopInternal() {
        if (this._internalState === InternalState.STARTED) {
            this.status = Status_1.default.SUCCEEDED;
            this.listener = null;
        }
        this._internalState = InternalState.STOPPED;
    }
    _stop() {
        if (this.listener) {
            this.listener.cancel();
            this.listener = null;
        }
        this._internalState = InternalState.STOPPED;
        return Promise.resolve();
    }
    update(result) {
        if (this.status === Status_1.default.IN_PROGRESS) {
            return result;
        }
        else {
            return this.status;
        }
    }
    destroy() {
        super.destroy();
        this.getOptions = null;
        this.getRulePath = null;
        this.onResult = null;
        this.status = null;
    }
}
exports.default = SucceedOnListenJs;

},{"../../Runtime":1,"../Decorator":7,"../Status":10,"@jibo/jetstream-client":undefined,"events":undefined}],43:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Decorator_1 = require("../Decorator");
const Status_1 = require("../Status");
class TimeoutFail extends Decorator_1.default {
    start() {
        this.startTime = Date.now();
        return true;
    }
    update(result) {
        const elapsed = Date.now() - this.startTime;
        if (elapsed > this.options.timeout) {
            this.behavior._stop();
            return Status_1.default.FAILED;
        }
        return result;
    }
}
exports.default = TimeoutFail;

},{"../Decorator":7,"../Status":10}],44:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Decorator_1 = require("../Decorator");
const Status_1 = require("../Status");
class TimeoutSucceed extends Decorator_1.default {
    start() {
        this.startTime = Date.now();
        return true;
    }
    update(result) {
        const elapsed = Date.now() - this.startTime;
        if (elapsed > this.options.timeout) {
            return Status_1.default.SUCCEEDED;
        }
        return result;
    }
}
exports.default = TimeoutSucceed;

},{"../Decorator":7,"../Status":10}],45:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Decorator_1 = require("../Decorator");
const Status_1 = require("../Status");
class TimeoutSucceedJs extends Decorator_1.default {
    start() {
        this.startTime = Date.now();
        this.timeout = this.options.getTime();
        return true;
    }
    update(result) {
        const elapsed = Date.now() - this.startTime;
        if (elapsed > this.timeout) {
            return Status_1.default.SUCCEEDED;
        }
        return result;
    }
}
exports.default = TimeoutSucceedJs;

},{"../Decorator":7,"../Status":10}],46:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Decorator_1 = require("../Decorator");
const Status_1 = require("../Status");
class WhileCondition extends Decorator_1.default {
    constructor(options) {
        super(options, {
            init: function () { }
        });
        this.doInit = true;
    }
    start() {
        if (this.doInit) {
            this.options.init();
            this.doInit = false;
        }
        return true;
    }
    update(result) {
        if (result === Status_1.default.SUCCEEDED && this.options.conditional()) {
            return this.behavior._start() ? Status_1.default.IN_PROGRESS : Status_1.default.FAILED;
        }
        this.doInit = result !== Status_1.default.IN_PROGRESS;
        return result;
    }
}
exports.default = WhileCondition;

},{"../Decorator":7,"../Status":10}],47:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Case_1 = require("./Case");
const FailOnCondition_1 = require("./FailOnCondition");
const StartOnAnimEvent_1 = require("./StartOnAnimEvent");
const StartOnCondition_1 = require("./StartOnCondition");
const StartOnEvent_1 = require("./StartOnEvent");
const SucceedOnCondition_1 = require("./SucceedOnCondition");
const SucceedOnEmbedded_1 = require("./SucceedOnEmbedded");
const SucceedOnEvent_1 = require("./SucceedOnEvent");
const SucceedOnListen_1 = require("./SucceedOnListen");
const SucceedOnListenJs_1 = require("./SucceedOnListenJs");
const TimeoutFail_1 = require("./TimeoutFail");
const TimeoutSucceed_1 = require("./TimeoutSucceed");
const TimeoutSucceedJs_1 = require("./TimeoutSucceedJs");
const WhileCondition_1 = require("./WhileCondition");
exports.default = {
    Case: Case_1.default,
    FailOnCondition: FailOnCondition_1.default,
    StartOnAnimEvent: StartOnAnimEvent_1.default,
    StartOnCondition: StartOnCondition_1.default,
    StartOnEvent: StartOnEvent_1.default,
    SucceedOnCondition: SucceedOnCondition_1.default,
    SucceedOnEmbedded: SucceedOnEmbedded_1.default,
    SucceedOnEvent: SucceedOnEvent_1.default,
    SucceedOnListen: SucceedOnListen_1.default,
    SucceedOnListenJs: SucceedOnListenJs_1.default,
    TimeoutFail: TimeoutFail_1.default,
    TimeoutSucceed: TimeoutSucceed_1.default,
    TimeoutSucceedJs: TimeoutSucceedJs_1.default,
    WhileCondition: WhileCondition_1.default
};

},{"./Case":33,"./FailOnCondition":34,"./StartOnAnimEvent":35,"./StartOnCondition":36,"./StartOnEvent":37,"./SucceedOnCondition":38,"./SucceedOnEmbedded":39,"./SucceedOnEvent":40,"./SucceedOnListen":41,"./SucceedOnListenJs":42,"./TimeoutFail":43,"./TimeoutSucceed":44,"./TimeoutSucceedJs":45,"./WhileCondition":46}],48:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Status_1 = require("./Status");
exports.Status = Status_1.default;
const Factory_1 = require("./Factory");
exports.Factory = Factory_1.default;
const Blackboard_1 = require("./Blackboard");
exports.Blackboard = Blackboard_1.default;
const BehaviorTree_1 = require("./BehaviorTree");
exports.BehaviorTree = BehaviorTree_1.default;
const BehaviorEmitter_1 = require("./BehaviorEmitter");
exports.BehaviorEmitter = BehaviorEmitter_1.default;
const Behavior_1 = require("./Behavior");
exports.Behavior = Behavior_1.default;
const ParentBehavior_1 = require("./ParentBehavior");
exports.ParentBehavior = ParentBehavior_1.default;
const BaseElement_1 = require("./BaseElement");
exports.BaseElement = BaseElement_1.default;
const Decorator_1 = require("./Decorator");
exports.Decorator = Decorator_1.default;
const behaviors_1 = require("./behaviors");
exports.behaviors = behaviors_1.default;
const decorators_1 = require("./decorators");
exports.decorators = decorators_1.default;

},{"./BaseElement":2,"./Behavior":3,"./BehaviorEmitter":4,"./BehaviorTree":5,"./Blackboard":6,"./Decorator":7,"./Factory":8,"./ParentBehavior":9,"./Status":10,"./behaviors":31,"./decorators":47}],49:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log_1 = require("../log");
exports.default = log_1.default.createChild('BT');

},{"../log":75}],50:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log_1 = require("./log");
const log = log_1.default.createChild('GenerateListConfig');
exports.CONFIG_BASE = {
    viewConfig: {
        type: "MenuView",
        id: "mimMenu",
        ignoreSwipeDown: true,
        useEyeTransitions: true,
        title: null,
        listDefault: {
            menuButtonType: "ActionButton",
            colors: 'default'
        },
        list: [],
        soundSet: 'action'
    },
    open: {
        transitionOpen: 'trans_up',
        addView: null,
        removeToInclude: null
    },
    defaultClose: {
        remove: true,
        transitionClose: "trans_down"
    },
    defaultSelect: {
        remove: true,
        transitionClose: "trans_down"
    },
};
const BUTTON_BASE = {
    id: '',
    label: '',
    iconSrc: "core://resources/actionIcons/default.png",
    actions: [
        {
            type: "utterance",
            data: {
                utterance: ''
            }
        },
    ]
};
function isValue(value) {
    if (!value) {
        return true;
    }
    const valType = typeof value;
    if (valType === 'number' || valType === 'function' || valType === 'boolean' ||
        valType === 'string') {
        return true;
    }
    return false;
}
function mergeDeep(target, source) {
    for (const key in source) {
        if (isValue(source[key])) {
            target[key] = source[key];
        }
        else {
            if (Array.isArray(source[key])) {
                target[key] = [];
            }
            else {
                target[key] = {};
            }
            mergeDeep(target[key], source[key]);
        }
    }
    return target;
}
exports.mergeDeep = mergeDeep;
function default_1(menuConfig) {
    const config = mergeDeep({}, exports.CONFIG_BASE);
    config.viewConfig.title = menuConfig.title;
    config.viewConfig.ignoreSwipeDown = !menuConfig.allowSwipe;
    for (let i = 0; i < menuConfig.buttons.length; ++i) {
        let button = mergeDeep({}, BUTTON_BASE);
        button.id = button.label = menuConfig.buttons[i].label;
        let utterance = menuConfig.buttons[i].utterance;
        if (utterance[0] === '{') {
            try {
                utterance = JSON.parse(utterance);
            }
            catch (e) {
                log.warn('Unable to parse utterance as JSON: ', utterance);
                utterance = '';
            }
        }
        button.actions[0].data.utterance = utterance;
        button.iconSrc = menuConfig.buttons[i].icon;
        const colors = menuConfig.buttons[i].color;
        if (Array.isArray(colors)) {
            button.colors = colors.map((value) => {
                return parseInt(value.replace('#', '0x'));
            });
        }
        else {
            button.colors = colors;
        }
        config.viewConfig.list.push(button);
    }
    return config;
}
exports.default = default_1;

},{"./log":64}],51:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const MimPrompt_1 = require("./MimPrompt");
const MimState_1 = require("./MimState");
const WeightedRotation_1 = require("./WeightedRotation");
const fs = require("fs");
const vm = require("vm");
const path = require("path");
const jibo_embodied_dialog_1 = require("jibo-embodied-dialog");
const log_1 = require("./log");
const log = log_1.default.createChild('MimConfig');
var PromptCategory;
(function (PromptCategory) {
    PromptCategory["ENTRY"] = "Entry-Core";
    PromptCategory["ERROR"] = "Errors";
    PromptCategory["RESPONSE"] = "Response";
})(PromptCategory || (PromptCategory = {}));
var PromptSubCategory;
(function (PromptSubCategory) {
    PromptSubCategory["QUESTION"] = "Q";
    PromptSubCategory["ANNOUNCEMENT"] = "AN";
    PromptSubCategory["NO_MATCH"] = "NM";
    PromptSubCategory["NO_INPUT"] = "NI";
    PromptSubCategory["HOLD_RETURN"] = "HoldReturn";
    PromptSubCategory["VERBOSE"] = "Verbose";
    PromptSubCategory["TRUNCATED"] = "Truncated";
    PromptSubCategory["THANKS"] = "Thanks";
})(PromptSubCategory || (PromptSubCategory = {}));
var ThanksOptions;
(function (ThanksOptions) {
    ThanksOptions["IGNORE"] = "ignore";
    ThanksOptions["RESPOND_AND_LISTEN"] = "respondAndListen";
    ThanksOptions["RESPOND_AND_END"] = "respondAndEnd";
})(ThanksOptions = exports.ThanksOptions || (exports.ThanksOptions = {}));
var MimTypes;
(function (MimTypes) {
    MimTypes["ANNOUNCEMENT"] = "announcement";
    MimTypes["OPTIONAL_RESPONSE"] = "optional-response";
    MimTypes["QUESTION"] = "question";
})(MimTypes = exports.MimTypes || (exports.MimTypes = {}));
class MimConfig {
    static load(filePath) {
        return new Promise((resolve, reject) => {
            fs.readFile(filePath, 'utf8', (error, result) => {
                if (error) {
                    reject(error);
                }
                else {
                    let mim = new MimConfig();
                    mim.mimId = path.basename(filePath, path.extname(filePath));
                    mim.initWithJSON(JSON.parse(result));
                    resolve(mim);
                }
            });
        });
    }
    constructor() {
        this.mimId = '';
        this.mimType = null;
        this.ruleNames = [];
        this.gui = null;
        this.timeout = 0;
        this.noMatchesForGUI = 0;
        this.noInputsForGUI = 0;
        this.bargeIn = true;
        this.esAutoTagging = true;
        this.ignoreNoMatch = false;
        this.activeListenMode = null;
        this.thanksHandling = ThanksOptions.IGNORE;
        this.parseAllASR = false;
        this.parseLaunch = false;
        this.hintPhrases = '';
        this.fastEosArray = '';
        this.prompts = [];
    }
    get hasGui() {
        return (!!this.gui && !!this.gui.data);
    }
    getOriginalPromptText(id) {
        for (let i = 0; i < this.prompts.length; ++i) {
            if (this.prompts[i].id === id) {
                return this.prompts[i].prompt;
            }
        }
        return null;
    }
    getPromptText(mimState, promptData, rotationNode) {
        let entryPromptSubCategory;
        switch (this.mimType) {
            case MimTypes.QUESTION:
                entryPromptSubCategory = PromptSubCategory.QUESTION;
                break;
            case MimTypes.ANNOUNCEMENT:
                entryPromptSubCategory = PromptSubCategory.ANNOUNCEMENT;
                break;
            case MimTypes.OPTIONAL_RESPONSE:
                entryPromptSubCategory = PromptSubCategory.ANNOUNCEMENT;
                break;
            default:
                log.debug(`In MiM ${this.mimId}, incorrect mimType of ${this.mimType}`);
                break;
        }
        if (!mimState) {
            const prompt = this.getPromptWithCategoryAndSubCategory(PromptCategory.ENTRY, entryPromptSubCategory, null, rotationNode);
            return { id: prompt.id, text: prompt.getPromptText().trim(), autoRuleOverride: prompt.autoRuleOverride };
        }
        let promptDataSandbox;
        if (promptData) {
            promptDataSandbox = this.getSandbox(promptData);
        }
        let prompt = null;
        switch (mimState.lastResultState) {
            case MimState_1.States.ENTRY:
                prompt = this.getPromptWithCategoryAndSubCategory(PromptCategory.ENTRY, entryPromptSubCategory, promptDataSandbox, rotationNode);
                break;
            case MimState_1.States.VERBOSE:
                prompt = this.getPromptWithCategoryAndSubCategory(PromptCategory.ENTRY, PromptSubCategory.VERBOSE, promptDataSandbox, rotationNode);
                if (!prompt) {
                    prompt = this.getPromptWithCategoryAndSubCategory(PromptCategory.ENTRY, entryPromptSubCategory, promptDataSandbox, rotationNode);
                }
                break;
            case MimState_1.States.TRUNCATED:
                prompt = this.getPromptWithCategoryAndSubCategory(PromptCategory.ENTRY, PromptSubCategory.TRUNCATED, promptDataSandbox, rotationNode);
                if (!prompt) {
                    prompt = this.getPromptWithCategoryAndSubCategory(PromptCategory.ENTRY, entryPromptSubCategory, promptDataSandbox, rotationNode);
                }
                break;
            case MimState_1.States.HOLD_RETURN:
                prompt = this.getPromptWithCategoryAndSubCategory(PromptCategory.ENTRY, PromptSubCategory.HOLD_RETURN, promptDataSandbox, rotationNode);
                if (!prompt) {
                    prompt = this.getPromptWithCategoryAndSubCategory(PromptCategory.ENTRY, entryPromptSubCategory, promptDataSandbox, rotationNode);
                }
                break;
            case MimState_1.States.THANKS:
                prompt = this.getPromptWithCategoryAndSubCategory(PromptCategory.RESPONSE, PromptSubCategory.THANKS, promptDataSandbox, rotationNode);
                break;
            case MimState_1.States.NO_MATCH:
                prompt = this.getErrorPrompt(PromptSubCategory.NO_MATCH, promptDataSandbox, mimState.noMatchCount, rotationNode);
                break;
            case MimState_1.States.NO_INPUT:
                prompt = this.getErrorPrompt(PromptSubCategory.NO_INPUT, promptDataSandbox, mimState.noInputCount, rotationNode);
                break;
            default:
                log.debug(`getPromptText() - Invalid lastResultState: ${mimState.lastResultState}`);
                break;
        }
        if (rotationNode) {
            rotationNode.save();
        }
        if (!prompt) {
            return { id: null, text: '', autoRuleOverride: null };
        }
        if (prompt.media !== 'TTS') {
            return { id: prompt.id, text: '', autoRuleOverride: prompt.autoRuleOverride };
        }
        let promptText = '';
        if (promptDataSandbox) {
            let script_text = '`' + prompt.getPromptText() + '`';
            try {
                promptText = vm.runInContext(script_text, promptDataSandbox);
            }
            catch (e) {
                log.warn(`Error parsing prompt text for ${prompt.id}: ${prompt.getPromptText()} - error: ${e.message}`);
            }
        }
        else {
            promptText = prompt.getPromptText();
        }
        return { id: prompt.id, text: promptText, autoRuleOverride: prompt.autoRuleOverride };
    }
    getJavascriptGUI(promptData) {
        if (!this.gui || !this.gui.data || this.gui.type !== 'Javascript') {
            return null;
        }
        const sandbox = this.getSandbox(promptData);
        let viewConfig = null;
        let code = this.gui.data;
        try {
            if (code.match(/^\s*{/)) {
                code = '(function() {\nreturn ' + code + '})()';
                viewConfig = vm.runInContext(code, sandbox);
            }
            else {
                code = '(function() {\n' + code + '})()';
                viewConfig = vm.runInContext(code, sandbox);
            }
        }
        catch (e) {
            log.warn(`Error when trying to get GUI for MIM ${this.mimId}: `, e);
        }
        return viewConfig;
    }
    hasErrorPrompt(error, index) {
        let errorCategory;
        if (error === 'noInput') {
            errorCategory = PromptSubCategory.NO_INPUT;
        }
        else if (error === 'noMatch') {
            errorCategory = PromptSubCategory.NO_MATCH;
        }
        else {
            return false;
        }
        for (let prompt of this.prompts) {
            if (prompt.promptCategory === PromptCategory.ERROR &&
                prompt.promptSubCategory === errorCategory && prompt.index === index) {
                return true;
            }
        }
        return false;
    }
    hasVerbosePrompt() {
        for (let prompt of this.prompts) {
            if (prompt.promptCategory === PromptCategory.ENTRY &&
                prompt.promptSubCategory === PromptSubCategory.VERBOSE) {
                return true;
            }
        }
        return false;
    }
    hasTruncatedPrompt() {
        for (let prompt of this.prompts) {
            if (prompt.promptCategory === PromptCategory.ENTRY &&
                prompt.promptSubCategory === PromptSubCategory.TRUNCATED) {
                return true;
            }
        }
        return false;
    }
    hasThanksPrompt() {
        for (let prompt of this.prompts) {
            if (prompt.promptCategory === PromptCategory.RESPONSE &&
                prompt.promptSubCategory === PromptSubCategory.THANKS) {
                return true;
            }
        }
        return false;
    }
    calculateRules(promptData) {
        const rule = this.runSandboxed('`' + this.originalRuleNames + '`', promptData);
        const rules = rule.split(',');
        this.ruleNames = rules.map(rule => rule.trim()).filter(rule => !!rule);
    }
    initWithJSON(data) {
        this.original = data;
        if (!this.mimId) {
            this.mimId = data.mim_id || "";
        }
        this.mimType = data.mim_type;
        if (this.mimType === 'announce') {
            this.mimType = MimTypes.ANNOUNCEMENT;
        }
        if (typeof data.rule_name === 'string') {
            this.originalRuleNames = data.rule_name;
        }
        if (data.gui) {
            this.gui = data.gui;
        }
        else if (data.sample_utterances) {
            const gui = {
                title: '',
                buttons: []
            };
            const utterances = data.sample_utterances.split(',');
            for (let i = 0; i < utterances.length; ++i) {
                const utter = utterances[i].trim();
                const button = {
                    label: utter,
                    color: 'default',
                    icon: '',
                    utterance: utter,
                    notes: ''
                };
                if (utter.toLowerCase() === 'yes') {
                    button.color = 'confirm';
                    button.icon = 'jibo://resources/actionIcons/ok.png';
                }
                else if (utter.toLowerCase() === 'no') {
                    button.color = 'cancel';
                    button.icon = 'jibo://resources/actionIcons/cancel.png';
                }
                gui.buttons.push(button);
            }
            this.gui = {
                type: 'Menu',
                data: gui,
                pause: true
            };
        }
        this.timeout = parseFloat(data.timeout);
        if (this.mimType !== MimTypes.ANNOUNCEMENT && !(this.timeout > 0)) {
            log.debug(`Timeout is an invalid value (${this.timeout}) in mim ${this.mimId}`);
            this.timeout = 6;
        }
        if (data.num_tries_for_gui) {
            this.noInputsForGUI = this.noMatchesForGUI = parseInt(data.num_tries_for_gui);
        }
        else {
            this.noInputsForGUI = parseInt(data.no_inputs_for_gui);
            this.noMatchesForGUI = parseInt(data.no_matches_for_gui);
        }
        if (!(this.noMatchesForGUI >= 0)) {
            this.noMatchesForGUI = 0;
        }
        if (!(this.noInputsForGUI >= 0)) {
            this.noInputsForGUI = 0;
        }
        this.bargeIn = data.barge_in !== false;
        this.esAutoTagging = data.es_auto_tagging === undefined ? true : data.es_auto_tagging;
        if (this.mimType === MimTypes.OPTIONAL_RESPONSE) {
            this.ignoreNoMatch = true;
            this.activeListenMode = jibo_embodied_dialog_1.listen.ActiveListenMode.OPTIONAL_RESPONSE;
        }
        if (data.listenMode) {
            switch (data.listenMode) {
                case 'OR':
                case 'OPTIONAL_RESPONSE':
                    this.activeListenMode = jibo_embodied_dialog_1.listen.ActiveListenMode.OPTIONAL_RESPONSE;
                    break;
                case 'UI':
                    this.activeListenMode = jibo_embodied_dialog_1.listen.ActiveListenMode.UI;
                    break;
                case 'NO_BODY':
                    break;
            }
        }
        if (this.mimType === MimTypes.OPTIONAL_RESPONSE) {
            this.thanksHandling = data.thanks_handling || ThanksOptions.IGNORE;
        }
        this.parseAllASR = data.parse_all_asr === true;
        if (this.mimType === MimTypes.OPTIONAL_RESPONSE) {
            this.parseLaunch = data.parse_launch === true;
        }
        if (data.hint_phrases || data.fast_eos_array) {
            if (data.hint_phrases) {
                this.hintPhrases = data.hint_phrases;
            }
            if (data.fast_eos_array) {
                this.fastEosArray = data.fast_eos_array;
            }
        }
        else if (data.parse_yes_no === true) {
            const yesno = '$YESNO';
            this.hintPhrases = yesno;
            this.fastEosArray = yesno;
        }
        if (data.prompts) {
            for (let prompt_data of data.prompts) {
                this.addPromptWithJSON(prompt_data);
            }
        }
    }
    runSandboxed(code, promptData) {
        const context = this.getSandbox(promptData);
        return vm.runInContext(code, context);
    }
    getPromptWithCategoryAndSubCategory(category, sub_category, promptData, rotationNode) {
        let prompts = [];
        let result = null;
        let usedPromptIds = null;
        if (rotationNode) {
            let mimData = rotationNode.data[this.mimId];
            if (!mimData) {
                mimData = rotationNode.data[this.mimId] = {};
            }
            usedPromptIds = mimData[sub_category];
            if (!usedPromptIds || Array.isArray(usedPromptIds)) {
                usedPromptIds = mimData[sub_category] = {};
            }
        }
        for (let prompt of this.prompts) {
            if (prompt.promptCategory === category && prompt.promptSubCategory === sub_category) {
                prompts.push(prompt);
            }
        }
        result = WeightedRotation_1.selectItem(prompts, (prompt) => {
            return this.promptMeetsCondition(prompt, promptData);
        }, usedPromptIds);
        return result;
    }
    getErrorPrompt(promptSubCategory, promptData, index, rotationNode) {
        let prompts = [];
        let result = null;
        let usedPromptIds = null;
        if (rotationNode) {
            let mimData = rotationNode.data[this.mimId];
            if (!mimData) {
                mimData = rotationNode.data[this.mimId] = {};
            }
            usedPromptIds = mimData[promptSubCategory + '_' + index];
            if (!usedPromptIds || Array.isArray(usedPromptIds)) {
                usedPromptIds = mimData[promptSubCategory + '_' + index] = {};
            }
        }
        for (let prompt of this.prompts) {
            if (prompt.promptCategory === PromptCategory.ERROR &&
                prompt.promptSubCategory === promptSubCategory &&
                prompt.index === index) {
                prompts.push(prompt);
            }
        }
        result = WeightedRotation_1.selectItem(prompts, (prompt) => {
            return this.promptMeetsCondition(prompt, promptData);
        }, usedPromptIds);
        return result;
    }
    promptMeetsCondition(prompt, promptData) {
        if (!promptData || !prompt.condition) {
            return true;
        }
        if (prompt.weight && prompt.weight <= 0) {
            return false;
        }
        let condition = prompt.condition.replace(/^\$\{/, "").replace(/\}$/, "");
        try {
            return !!vm.runInContext(condition, promptData);
        }
        catch (e) {
            log.warn(`error evaluating prompt condition for ${prompt.id}: ${prompt.condition} - error: ${e.message}`);
            return false;
        }
    }
    addPromptWithJSON(data) {
        this.prompts.push(new MimPrompt_1.default(data));
    }
    getSandbox(promptData) {
        if (!this.vmContext) {
            this.vmContext = vm.createContext(promptData);
        }
        return this.vmContext;
    }
}
exports.default = MimConfig;

},{"./MimPrompt":53,"./MimState":55,"./WeightedRotation":56,"./log":64,"fs":undefined,"jibo-embodied-dialog":undefined,"path":undefined,"vm":undefined}],52:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
const jibo_typed_events_1 = require("jibo-typed-events");
const Runtime_1 = require("../../Runtime");
const MimRepeatManager_1 = require("./MimRepeatManager");
const MimConfig_1 = require("./MimConfig");
const MimState_1 = require("./MimState");
const jibo_plugins_1 = require("jibo-plugins");
const fs = require("fs");
const path = require("path");
const GlobalListenDelegate_1 = require("./delegates/GlobalListenDelegate");
const WeightedRotation_1 = require("./WeightedRotation");
var HJCompleteReason;
(function (HJCompleteReason) {
    HJCompleteReason[HJCompleteReason["HJ_ONLY"] = 0] = "HJ_ONLY";
    HJCompleteReason[HJCompleteReason["NO_MATCH"] = 1] = "NO_MATCH";
    HJCompleteReason[HJCompleteReason["NON_INTERRUPTING"] = 2] = "NON_INTERRUPTING";
})(HJCompleteReason = exports.HJCompleteReason || (exports.HJCompleteReason = {}));
class SingletonEnforcer {
}
class MimManager extends events_1.EventEmitter {
    constructor(enforcer) {
        super();
        this.MimConfig = MimConfig_1.default;
        this.States = MimState_1.States;
        this.GlobalListenDelegate = GlobalListenDelegate_1.default;
        this.isHeyJiboActive = false;
        this.timeoutIgnoresSimulator = false;
        this.shouldShowGUI = false;
        this.silentMenus = false;
        this.listenDelegate = GlobalListenDelegate_1.default;
        this.speakDelegate = Runtime_1.default.instance.embodied.speech;
        this.kbModels = {};
        this.end = new jibo_typed_events_1.Event('End MIM');
        this.end.setMode(jibo_typed_events_1.EmitterMode.LAST_HANDLER);
        this.openGUI = new jibo_typed_events_1.Event('Open MIM GUI');
        this.openGUI.setMode(jibo_typed_events_1.EmitterMode.LAST_HANDLER);
        this.handleSpeech = new jibo_typed_events_1.Event('Handle Spoofed Utterance');
        this.handleSpeech.setMode(jibo_typed_events_1.EmitterMode.LAST_HANDLER);
        this.heyJibo = new jibo_typed_events_1.Event('Hey Jibo Heard');
        this.heyJibo.setMode(jibo_typed_events_1.EmitterMode.LAST_HANDLER);
        this.heyJiboComplete = new jibo_typed_events_1.Event('Hey Jibo Completed');
        this.heyJiboComplete.setMode(jibo_typed_events_1.EmitterMode.LAST_HANDLER);
        this.onHeyJiboHeard = this.onHeyJiboHeard.bind(this);
        this.onHJOnly = this.onHJOnly.bind(this);
        this.onHJNoMatch = this.onHJNoMatch.bind(this);
        this.onShortGlobal = this.onShortGlobal.bind(this);
        this.onHJEnd = this.onHJEnd.bind(this);
        const origHJOn = this.heyJibo.on;
        this.heyJibo.on = (handler) => {
            this.attachHJListeners();
            this.heyJibo.on = origHJOn;
            return this.heyJibo.on(handler);
        };
        if (Runtime_1.default.instance.runMode === Runtime_1.default.instance.RunMode.UNIT_TESTS) {
            this.selectItem = WeightedRotation_1.selectItem;
        }
    }
    static get instance() {
        if (!MimManager._instance) {
            MimManager._instance = new MimManager(new SingletonEnforcer());
        }
        return MimManager._instance;
    }
    loadMimKB(assetPack) {
        if (assetPack.endsWith('://')) {
            assetPack = assetPack.substring(0, assetPack.length - 3);
        }
        if (assetPack === 'core') {
            assetPack = 'jibo';
        }
        if (!assetPack) {
            try {
                const skillJSON = JSON.parse(fs.readFileSync(path.resolve(process.cwd(), 'package.json'), 'utf8'));
                assetPack = skillJSON.name;
            }
            catch (e) {
                return Promise.reject(e);
            }
        }
        assetPack = assetPack.toLowerCase().replace(/[^a-z0-9\/_-]/g, '');
        if (this.kbModels[assetPack]) {
            return this.kbModels[assetPack].loadRoot();
        }
        const sliceName = assetPack === 'jibo ' ? '/jibo/mims' : `/skills/${assetPack}/mims`;
        return Runtime_1.default.instance.kb.createSlice(sliceName)
            .then(() => {
            const model = Runtime_1.default.instance.kb.createModel(sliceName);
            this.kbModels[assetPack] = model;
            return model.loadRoot();
        });
    }
    loadMimAssets() {
        if (!this.globalMimLoad) {
            const loadThanks = MimConfig_1.default.load(jibo_plugins_1.PathUtils.getAssetUri('core://mims/en-us/globals/ThanksResponse.mim'))
                .then((config) => {
                this.thanksResponse = config;
            });
            this.repeat = new MimRepeatManager_1.default();
            const loadRotation = this.loadMimKB('jibo').then((node) => {
                this.jiboRotationNode = node;
            });
            this.globalMimLoad = Promise.all([loadThanks, this.repeat.init(), loadRotation]);
        }
    }
    attachHJListeners() {
        const events = Runtime_1.default.instance.jetstream.events;
        events.hjHeard.on(this.onHeyJiboHeard);
        events.globalTurnResult.on(this.onHJEnd);
        const shared = Runtime_1.default.instance.globalEvents.shared;
        shared.hjOnly.on(this.onHJOnly);
        shared.noGlobalMatch.on(this.onHJNoMatch);
        shared.nonInterruptingGlobal.on(this.onShortGlobal);
    }
    onHeyJiboHeard() {
        this.isHeyJiboActive = true;
        this.heyJibo.emit();
    }
    onHJOnly() {
        this.isHeyJiboActive = false;
        this.heyJiboComplete.emit(HJCompleteReason.HJ_ONLY);
    }
    onHJNoMatch() {
        this.isHeyJiboActive = false;
        this.heyJiboComplete.emit(HJCompleteReason.NO_MATCH);
    }
    onShortGlobal() {
        this.isHeyJiboActive = false;
        this.heyJiboComplete.emit(HJCompleteReason.NON_INTERRUPTING);
    }
    onHJEnd() {
        this.isHeyJiboActive = false;
    }
}
exports.default = MimManager;

},{"../../Runtime":1,"./MimConfig":51,"./MimRepeatManager":54,"./MimState":55,"./WeightedRotation":56,"./delegates/GlobalListenDelegate":59,"events":undefined,"fs":undefined,"jibo-plugins":undefined,"jibo-typed-events":undefined,"path":undefined}],53:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class MimPrompt {
    constructor(data) {
        this.id = data.prompt_id;
        this.promptCategory = data.prompt_category;
        this.promptSubCategory = data.prompt_sub_category;
        this.index = parseInt(data.index);
        this.condition = data.condition;
        this.prompt = data.prompt;
        this.media = data.media;
        this.autoRuleOverride = data.auto_rule_override;
        if (this.autoRuleOverride === undefined) {
            this.autoRuleOverride = null;
        }
        if (data.weight !== undefined && parseFloat(data.weight) === 0) {
            this.weight = 0;
        }
        else {
            this.weight = parseFloat(data.weight) || 1;
        }
    }
    getPromptText() {
        let result = this.prompt;
        return result;
    }
}
exports.default = MimPrompt;

},{}],54:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const MimConfig_1 = require("./MimConfig");
const jibo_plugins_1 = require("jibo-plugins");
class MimRepeatManager {
    constructor() {
        this.maxRepeat = 10;
        this.repeatMimQ = null;
        this.repeatMimANOR = null;
        this.repeatActionQ = null;
        this.repeatActionANOR = null;
    }
    init() {
        this.repeatMimQ = [];
        this.repeatMimQ.length = 10;
        this.repeatMimQ.fill(null, 0, 10);
        this.repeatMimANOR = [];
        this.repeatMimANOR.length = 10;
        this.repeatMimANOR.fill(null, 0, 10);
        this.repeatActionQ = ['cached'];
        this.repeatActionQ.length = 10;
        this.repeatActionQ.fill('verbose', 1, 8);
        this.repeatActionQ[9] = 'exit';
        this.repeatActionANOR = [];
        this.repeatActionANOR.length = 10;
        this.repeatActionANOR.fill('cached', 0, 8);
        this.repeatActionANOR[9] = 'exit';
        let promises = [
            'core://mims/en-us/globals/RepeatORANFirst.mim',
            'core://mims/en-us/globals/RepeatORANSecond.mim',
            'core://mims/en-us/globals/RepeatORANThird.mim',
            'core://mims/en-us/globals/RepeatORANNoMore.mim',
            'core://mims/en-us/globals/RepeatQuestionFirst.mim',
            'core://mims/en-us/globals/RepeatQuestionSecond.mim',
            'core://mims/en-us/globals/RepeatQuestionThird.mim',
            'core://mims/en-us/globals/RepeatQuestionNoMore.mim',
        ];
        for (let i = 0; i < promises.length; ++i) {
            promises[i] = MimConfig_1.default.load(jibo_plugins_1.PathUtils.getAssetUri(promises[i]));
        }
        return Promise.all(promises).then((results) => {
            this.repeatMimANOR[0] = results[0];
            this.repeatMimANOR[1] = results[1];
            this.repeatMimANOR.fill(results[2], 2, 8);
            this.repeatMimANOR[9] = results[3];
            this.repeatMimQ[0] = results[4];
            this.repeatMimQ[1] = results[5];
            this.repeatMimQ[2] = results[6];
            this.repeatMimQ[9] = results[7];
        });
    }
    getRepeat(mimType, repeatCount) {
        const mims = mimType === MimConfig_1.MimTypes.QUESTION ? this.repeatMimQ : this.repeatMimANOR;
        const actions = mimType === MimConfig_1.MimTypes.QUESTION ? this.repeatActionQ : this.repeatActionANOR;
        let prompt;
        if (mims[repeatCount - 1]) {
            prompt = mims[repeatCount - 1].getPromptText(null, null).text + ' ';
        }
        else {
            prompt = '';
        }
        return {
            action: actions[repeatCount - 1],
            prompt
        };
    }
}
exports.default = MimRepeatManager;

},{"./MimConfig":51,"jibo-plugins":undefined}],55:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var States;
(function (States) {
    States["ENTRY"] = "entry";
    States["MATCH"] = "match";
    States["NO_MATCH"] = "noMatch";
    States["NO_INPUT"] = "noInput";
    States["REPEAT"] = "repeat";
    States["THANKS"] = "thanks";
    States["HOLD_RETURN"] = "holdReturn";
    States["VERBOSE"] = "verbose";
    States["TRUNCATED"] = "truncated";
    States["MENU_CLOSED"] = "MenuClosed";
})(States = exports.States || (exports.States = {}));
class MimState {
    constructor() {
        this.noInputCount = 0;
        this.noMatchCount = 0;
        this.lastResultState = States.ENTRY;
        this.success = false;
        this.failure = false;
        this.promptText = '';
        this.promptAutoRules = null;
    }
    reset() {
        this.noInputCount = 0;
        this.noMatchCount = 0;
        this.lastResultState = States.ENTRY;
        this.success = false;
        this.failure = false;
        this.promptText = '';
        this.promptAutoRules = null;
    }
    get done() {
        return (this.success || this.failure);
    }
    get errors() {
        return this.noInputCount + this.noMatchCount;
    }
    incrementNoInputCount() {
        this.noInputCount++;
    }
    incrementNoMatchCount() {
        this.noMatchCount++;
    }
    shouldShowGUI(config) {
        return config.hasGui && (this.noMatchCount >= config.noMatchesForGUI ||
            this.noInputCount >= config.noInputsForGUI);
    }
}
exports.default = MimState;

},{}],56:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class ItemStandin {
    constructor(original, usedDict) {
        this.orig = original;
        this.id = original.id;
        if (usedDict && typeof usedDict[this.id] === 'number') {
            this.weight = original.weight - usedDict[this.id];
        }
        else {
            this.weight = original.weight;
        }
        this.valid = undefined;
    }
}
function selectItem(itemList, validCheck, usedDict) {
    if (!itemList || !itemList.length) {
        return null;
    }
    let itemOptions = [];
    let result = null;
    let usedItems = [];
    for (let item of itemList) {
        if (usedDict && usedDict[item.id] === true) {
            usedItems.push(new ItemStandin(item, usedDict));
            continue;
        }
        if (item.weight > 0 && validCheck(item)) {
            const standin = new ItemStandin(item, usedDict);
            standin.valid = true;
            if (standin.weight <= 0) {
                usedItems.push(standin);
            }
            else {
                itemOptions.push(standin);
            }
        }
    }
    result = selectWeightedItem(itemOptions, usedItems, usedDict);
    if (!result && usedItems.length) {
        for (const prop in usedDict) {
            delete usedDict[prop];
        }
        let maxWeight = 0;
        for (let item of usedItems) {
            if (item.valid || validCheck(item.orig)) {
                item.weight = item.orig.weight;
                itemOptions.push(item);
                if (item.weight > maxWeight) {
                    maxWeight = item.weight;
                }
            }
        }
        if (maxWeight < 1) {
            const normalizer = 1 / maxWeight;
            for (let item of itemOptions) {
                item.weight *= normalizer;
            }
        }
        result = selectWeightedItem(itemOptions, usedItems, usedDict);
    }
    if (result && usedDict) {
        const id = result.id;
        if (result.weight > 1) {
            usedDict[id] = usedDict[id] ? usedDict[id] + 1 : 1;
        }
        else {
            usedDict[id] = true;
        }
    }
    return result ? result.orig : null;
}
exports.selectItem = selectItem;
function selectWeightedItem(items, usedItems, usedDict) {
    if (items.length === 0) {
        return null;
    }
    let result = null;
    let totalWeight = 0;
    let length = items.length;
    for (let i = 0; i < length; ++i) {
        totalWeight += items[i].weight;
    }
    while (!result && length > 0) {
        const rand = Math.random() * totalWeight;
        let ongoingWeight = 0;
        for (let i = 0; i < length; ++i) {
            ongoingWeight += items[i].weight;
            if (rand <= ongoingWeight) {
                result = items[i];
                break;
            }
        }
        if (usedDict && result.weight < 1 && Math.random() >= result.weight) {
            usedItems.push(result);
            items.splice(items.indexOf(result), 1);
            usedDict[result.id] = true;
            totalWeight -= result.weight;
            length -= 1;
            result = null;
        }
    }
    return result;
}

},{}],57:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class EmptyAnalytics {
    constructor() {
        this.currentSkill = 'none';
    }
    track(event, data) {
    }
    flush() {
    }
}
exports.default = EmptyAnalytics;

},{}],58:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../../../Runtime");
exports.EXIT_TYPE = {
    INTERRUPT: 'interruption',
    SUCCESS: 'success',
    MAX_NI: 'max_no_input',
    MAX_NM: 'max_no_match'
};
exports.INTERRUPT_STATE = {
    SPEECH: 'speech',
    LISTEN: 'listen'
};
exports.INPUT = {
    SPEECH: 'speech',
    TOUCH: 'touch',
    SILENCE: 'silence',
    INTERRUPT: 'interrupted',
    NONE: 'n/a'
};
exports.NONE = 'n/a';
function end(base, exit_type, input_type, intent_selected, text, interruption_state, prev_prompt_id, total_no_matches, total_no_inputs) {
    Runtime_1.default.instance.analytics.track('Mim End', Object.assign({
        exit_type,
        modality: input_type || '',
        user_response: intent_selected || exports.NONE,
        user_response_text: text,
        interruption_state: interruption_state || exports.NONE,
        prev_prompt_id: prev_prompt_id || 'silence',
        total_no_inputs,
        total_no_matches
    }, base));
}
exports.end = end;
function launch(base) {
    Runtime_1.default.instance.analytics.track('Mim Launch', Object.assign({}, base));
}
exports.launch = launch;
function nonEndingResult(base, input_type, intent, text, domain, prev_prompt_id) {
    Runtime_1.default.instance.analytics.track('Mim Non-ending Result', Object.assign({
        modality: input_type,
        user_response: intent,
        command_type: domain,
        prev_prompt_id: prev_prompt_id || 'silence',
        user_response_text: text
    }, base));
}
exports.nonEndingResult = nonEndingResult;
function nonEndingIgnored(base, input_type, intent, text, domain, prev_prompt_id) {
    Runtime_1.default.instance.analytics.track('Mim Non-ending Ignored', Object.assign({
        modality: input_type,
        user_response: intent,
        command_type: domain,
        prev_prompt_id: prev_prompt_id || 'silence',
        user_response_text: text
    }, base));
}
exports.nonEndingIgnored = nonEndingIgnored;
function noMatch(base, error_count, prev_prompt_id, text) {
    Runtime_1.default.instance.analytics.track('Mim No Match', Object.assign({
        error_count,
        prev_prompt_id: prev_prompt_id || 'silence',
        user_response_text: text
    }, base));
}
exports.noMatch = noMatch;
function noInput(base, error_count, prev_prompt_id) {
    Runtime_1.default.instance.analytics.track('Mim No Input', Object.assign({
        error_count,
        prev_prompt_id: prev_prompt_id || 'silence'
    }, base));
}
exports.noInput = noInput;
function recoveredException(base) {
    Runtime_1.default.instance.analytics.track('Mim Recovered From Exception', Object.assign({}, base));
}
exports.recoveredException = recoveredException;

},{"../../../Runtime":1}],59:[function(require,module,exports){
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const jetstream_client_1 = require("@jibo/jetstream-client");
const events_1 = require("events");
const ListenEvent_1 = require("./ListenEvent");
const Runtime_1 = require("../../../Runtime");
const log_1 = require("../log");
const log = log_1.default.createChild('GlobalListenDelegate');
class GlobalListener extends events_1.EventEmitter {
    static setAmbientMode(mode) {
        Runtime_1.default.instance.embodied.listen.setAmbientMode(mode);
    }
    static enterActiveMode(mode, options) {
        return Runtime_1.default.instance.embodied.listen.enterActiveMode(mode, options);
    }
    static exitActiveMode() {
        return Runtime_1.default.instance.embodied.listen.exitActiveMode();
    }
    static create(options) {
        return __awaiter(this, void 0, void 0, function* () {
            const listener = new GlobalListener();
            listener.init(options);
            listener.run();
            return listener;
        });
    }
    constructor() {
        super();
        this.stopped = false;
    }
    updateTurn(options) {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.initialized;
            if (this.stopped) {
                return;
            }
            this.turn.update(options);
        });
    }
    stop(cancelTurn = true) {
        this.removeAllListeners();
        if (this.turn && cancelTurn) {
            this.turn.cancel();
        }
        this.turn = null;
        this.stopped = true;
    }
    init(options) {
        return __awaiter(this, void 0, void 0, function* () {
            this.initialized = new Promise((resolve, reject) => {
                Runtime_1.default.instance.jetstream.startLocalTurn(options)
                    .then((turn) => {
                    this.turn = turn;
                    resolve();
                }, reject);
            });
            yield this.initialized;
            if (this.stopped) {
                this.turn.cancel();
                this.turn = null;
            }
        });
    }
    run() {
        return __awaiter(this, void 0, void 0, function* () {
            yield this.initialized;
            if (this.stopped) {
                return;
            }
            Runtime_1.default.instance.jetstream.events.localTurnStarted.emit();
            try {
                const data = yield this.turn.promise;
                if (this.stopped) {
                    return;
                }
                this.turn = null;
                switch (data.status) {
                    case jetstream_client_1.types.TurnResultType.INTERRUPTED:
                        this.emit(ListenEvent_1.default.INTERRUPTED);
                        break;
                    case jetstream_client_1.types.TurnResultType.SUCCEEDED:
                        this.emit(ListenEvent_1.default.CLOUD, data);
                        break;
                    case jetstream_client_1.types.TurnResultType.TIMEOUT:
                        this.emit(ListenEvent_1.default.TIMEOUT);
                        break;
                }
                const activeMode = Runtime_1.default.instance.embodied.listen.getActiveMode();
                if (!activeMode && data.status !== jetstream_client_1.types.TurnResultType.INTERRUPTED) {
                    try {
                        yield Runtime_1.default.instance.embodied.listen.waitForIdle(true);
                    }
                    catch (e) {
                        log.warn('Error waiting for EL to return to idle', e);
                    }
                }
                this.emit(ListenEvent_1.default.FINISHED);
                this.stop();
            }
            catch (e) {
                this.turn = null;
                this.emit(ListenEvent_1.default.FINISHED, null);
            }
        });
    }
}
exports.default = GlobalListener;

},{"../../../Runtime":1,"../log":64,"./ListenEvent":60,"@jibo/jetstream-client":undefined,"events":undefined}],60:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const ListenEvent = {
    CLOUD: 'CLOUD',
    FINISHED: 'FINISHED',
    INTERRUPTED: 'INTERRUPTED',
    TIMEOUT: 'TIMEOUT',
};
exports.default = ListenEvent;

},{}],61:[function(require,module,exports){
'use strict';
module.exports = function (blackboard, notepad, result, emitter) {
    return {
        'meta': {
            'version': 1,
            'name': 'NoInputException',
            'uri': '/Users/jon/mit/sdk5/packages/jibo/src/bt/mim/flows/NoInputException.flow'
        },
        'f5f79e38-b40a-4c5f-83a6-a62c8af42161': function () {
            return {
                'id': 'f5f79e38-b40a-4c5f-83a6-a62c8af42161',
                'name': 'Begin',
                'transitions': [{
                        'frm': 'f5f79e38-b40a-4c5f-83a6-a62c8af42161',
                        'to': '149e6048-3d51-48e8-afaf-a5c40729b563',
                        'value': ''
                    }],
                'exceptions': [],
                'class': 'Flow.Begin',
                'options': {
                    'inputParameters': () => {
                        return {};
                    }
                }
            };
        },
        '28e365cb-3b40-4a5f-adec-e2ff27739d64': function () {
            return {
                'id': '28e365cb-3b40-4a5f-adec-e2ff27739d64',
                'name': 'exit',
                'transitions': [],
                'exceptions': [],
                'class': 'Flow.End',
                'options': {
                    'getTransition': () => {
                        return;
                    }
                }
            };
        },
        '41987e17-23ac-4791-b7e1-4d5a149afed1': function () {
            return {
                'id': '41987e17-23ac-4791-b7e1-4d5a149afed1',
                'name': 'restart',
                'transitions': [],
                'exceptions': [],
                'class': 'Flow.End',
                'options': {
                    'getTransition': () => {
                        return;
                    }
                }
            };
        },
        '149e6048-3d51-48e8-afaf-a5c40729b563': function () {
            return {
                'id': '149e6048-3d51-48e8-afaf-a5c40729b563',
                'name': 'Final NI - You Still There?',
                'transitions': [
                    {
                        'frm': '149e6048-3d51-48e8-afaf-a5c40729b563',
                        'to': '8072f19c-a7c9-4243-91bb-da0e5b5b6324',
                        'value': 'yes'
                    },
                    {
                        'frm': '149e6048-3d51-48e8-afaf-a5c40729b563',
                        'to': 'cfbe95f1-b20e-4374-8288-6545ae6ede5b',
                        'value': 'no'
                    }
                ],
                'exceptions': [
                    {
                        'frm': '149e6048-3d51-48e8-afaf-a5c40729b563',
                        'to': 'acd4acbf-b76a-4e01-93d9-ea5f0ed06007',
                        'value': '~InteractionError.noMatch'
                    },
                    {
                        'frm': '149e6048-3d51-48e8-afaf-a5c40729b563',
                        'to': '1f39bc3c-f910-4473-a693-b3abe8f09d90',
                        'value': '~InteractionError.noInput'
                    }
                ],
                'class': 'Mim.Question',
                'options': {
                    'mimPath': 'mims/en-us/exceptions/FinalNI-YouStillThere.mim',
                    'getPromptData': () => {
                        return {};
                    },
                    'onStatus': status => {
                        let mimState = status.state;
                        let asrResults = status.asrResults;
                        let speakerIds = status.speakerIds;
                    },
                    'onSuccess': results => {
                        let mimState = results.state;
                        let asrResults = results.asrResults;
                        let speakerIds = results.speakerIds;
                        let transition = results.firstGrammarTag;
                        return transition;
                    },
                    'onFailure': results => {
                        let mimState = results.state;
                        let asrResults = results.asrResults;
                        let speakerIds = results.speakerIds;
                        let exception = results.exception;
                        return exception;
                    }
                }
            };
        },
        'acd4acbf-b76a-4e01-93d9-ea5f0ed06007': function () {
            return {
                'id': 'acd4acbf-b76a-4e01-93d9-ea5f0ed06007',
                'name': 'Final NI - No Match',
                'transitions': [{
                        'frm': 'acd4acbf-b76a-4e01-93d9-ea5f0ed06007',
                        'to': '41987e17-23ac-4791-b7e1-4d5a149afed1',
                        'value': ''
                    }],
                'exceptions': [],
                'class': 'Mim.Announcement',
                'options': {
                    'mimPath': 'mims/en-us/exceptions/FinalNI-NoMatch.mim',
                    'getPromptData': () => {
                        return {};
                    }
                }
            };
        },
        '8072f19c-a7c9-4243-91bb-da0e5b5b6324': function () {
            return {
                'id': '8072f19c-a7c9-4243-91bb-da0e5b5b6324',
                'name': 'Final NI - Recovery',
                'transitions': [{
                        'frm': '8072f19c-a7c9-4243-91bb-da0e5b5b6324',
                        'to': '41987e17-23ac-4791-b7e1-4d5a149afed1',
                        'value': ''
                    }],
                'exceptions': [],
                'class': 'Mim.Announcement',
                'options': {
                    'mimPath': 'mims/en-us/exceptions/FinalNI-Recovery.mim',
                    'getPromptData': () => {
                        return {};
                    }
                }
            };
        },
        '1f39bc3c-f910-4473-a693-b3abe8f09d90': function () {
            return {
                'id': '1f39bc3c-f910-4473-a693-b3abe8f09d90',
                'name': 'Final NI - Surrender',
                'transitions': [{
                        'frm': '1f39bc3c-f910-4473-a693-b3abe8f09d90',
                        'to': '28e365cb-3b40-4a5f-adec-e2ff27739d64',
                        'value': ''
                    }],
                'exceptions': [],
                'class': 'Mim.Announcement',
                'options': {
                    'mimPath': 'mims/en-us/exceptions/FinalNI-Surrender.mim',
                    'getPromptData': () => {
                        return {};
                    }
                }
            };
        },
        'cfbe95f1-b20e-4374-8288-6545ae6ede5b': function () {
            return {
                'id': 'cfbe95f1-b20e-4374-8288-6545ae6ede5b',
                'name': 'Final NI -Smartypants',
                'transitions': [{
                        'frm': 'cfbe95f1-b20e-4374-8288-6545ae6ede5b',
                        'to': '28e365cb-3b40-4a5f-adec-e2ff27739d64',
                        'value': ''
                    }],
                'exceptions': [],
                'class': 'Mim.Announcement',
                'options': {
                    'mimPath': 'mims/en-us/exceptions/FinalNI-Smartypants.mim',
                    'getPromptData': () => {
                        return {};
                    }
                }
            };
        }
    };
};
},{}],62:[function(require,module,exports){
'use strict';
module.exports = function (blackboard, notepad, result, emitter) {
    return {
        'meta': {
            'version': 1,
            'name': 'NoMatchException',
            'uri': '/Users/jon/mit/sdk5/packages/jibo/src/bt/mim/flows/NoMatchException.flow'
        },
        'f5f79e38-b40a-4c5f-83a6-a62c8af42161': function () {
            return {
                'id': 'f5f79e38-b40a-4c5f-83a6-a62c8af42161',
                'name': 'Begin',
                'transitions': [{
                        'frm': 'f5f79e38-b40a-4c5f-83a6-a62c8af42161',
                        'to': '1a10ac7c-2d90-4dd8-aaf3-7c2e3482f048',
                        'value': ''
                    }],
                'exceptions': [],
                'class': 'Flow.Begin',
                'options': {
                    'inputParameters': () => {
                        return {};
                    }
                }
            };
        },
        '28e365cb-3b40-4a5f-adec-e2ff27739d64': function () {
            return {
                'id': '28e365cb-3b40-4a5f-adec-e2ff27739d64',
                'name': 'exit',
                'transitions': [],
                'exceptions': [],
                'class': 'Flow.End',
                'options': {
                    'getTransition': () => {
                        return;
                    }
                }
            };
        },
        '9280d6d3-91ab-4813-9ab5-401ab5592fc8': function () {
            return {
                'id': '9280d6d3-91ab-4813-9ab5-401ab5592fc8',
                'name': 'restart',
                'transitions': [],
                'exceptions': [],
                'class': 'Flow.End',
                'options': {
                    'getTransition': () => {
                        return;
                    }
                }
            };
        },
        '1a10ac7c-2d90-4dd8-aaf3-7c2e3482f048': function () {
            return {
                'id': '1a10ac7c-2d90-4dd8-aaf3-7c2e3482f048',
                'name': 'Final NM - Want to Keep Trying',
                'transitions': [
                    {
                        'frm': '1a10ac7c-2d90-4dd8-aaf3-7c2e3482f048',
                        'to': '84af4933-6f6a-43f1-b1f1-4831710d3c12',
                        'value': 'no'
                    },
                    {
                        'frm': '1a10ac7c-2d90-4dd8-aaf3-7c2e3482f048',
                        'to': '4a745911-a5a6-455e-ab29-d1d76d6f01e4',
                        'value': 'yes'
                    }
                ],
                'exceptions': [
                    {
                        'frm': '1a10ac7c-2d90-4dd8-aaf3-7c2e3482f048',
                        'to': 'd2eebf5f-b2a5-4b6f-99fe-97504bb3ef83',
                        'value': '~InteractionError.noMatch'
                    },
                    {
                        'frm': '1a10ac7c-2d90-4dd8-aaf3-7c2e3482f048',
                        'to': '1101d00a-9cf1-4a82-94d3-8623abbd18b7',
                        'value': '~InteractionError.noInput'
                    }
                ],
                'class': 'Mim.Question',
                'options': {
                    'mimPath': 'mims/en-us/exceptions/FinalNM-WantToKeepTrying.mim',
                    'getPromptData': () => {
                        return {};
                    },
                    'onStatus': status => {
                        let mimState = status.state;
                        let asrResults = status.asrResults;
                        let speakerIds = status.speakerIds;
                    },
                    'onSuccess': results => {
                        let mimState = results.state;
                        let asrResults = results.asrResults;
                        let speakerIds = results.speakerIds;
                        let transition = results.firstGrammarTag;
                        return transition;
                    },
                    'onFailure': results => {
                        let mimState = results.state;
                        let asrResults = results.asrResults;
                        let speakerIds = results.speakerIds;
                        let exception = results.exception;
                        return exception;
                    }
                }
            };
        },
        '1101d00a-9cf1-4a82-94d3-8623abbd18b7': function () {
            return {
                'id': '1101d00a-9cf1-4a82-94d3-8623abbd18b7',
                'name': 'Final NM - Surrender',
                'transitions': [{
                        'frm': '1101d00a-9cf1-4a82-94d3-8623abbd18b7',
                        'to': '28e365cb-3b40-4a5f-adec-e2ff27739d64',
                        'value': ''
                    }],
                'exceptions': [],
                'class': 'Mim.Announcement',
                'options': {
                    'mimPath': 'mims/en-us/exceptions/FinalNM-Surrender.mim',
                    'getPromptData': () => {
                        return {};
                    }
                }
            };
        },
        '45f80d27-5a59-4c0b-a241-4b8ea274294b': {
            'id': '45f80d27-5a59-4c0b-a241-4b8ea274294b',
            'transitions': [],
            'exceptions': [],
            'class': 'Flow.Comment',
            'options': {}
        },
        '84af4933-6f6a-43f1-b1f1-4831710d3c12': function () {
            return {
                'id': '84af4933-6f6a-43f1-b1f1-4831710d3c12',
                'name': 'Final NM - No More',
                'transitions': [{
                        'frm': '84af4933-6f6a-43f1-b1f1-4831710d3c12',
                        'to': '28e365cb-3b40-4a5f-adec-e2ff27739d64',
                        'value': ''
                    }],
                'exceptions': [],
                'class': 'Mim.Announcement',
                'options': {
                    'mimPath': 'mims/en-us/exceptions/FinalNM-NoMore.mim',
                    'getPromptData': () => {
                        return {};
                    }
                }
            };
        },
        '1d0ca37e-be3c-4c33-af53-98bc012045a2': function () {
            return {
                'id': '1d0ca37e-be3c-4c33-af53-98bc012045a2',
                'name': 'Final NM - Even More NM',
                'transitions': [{
                        'frm': '1d0ca37e-be3c-4c33-af53-98bc012045a2',
                        'to': '45a2e357-05c6-41b4-a475-4f47ab2d7c36',
                        'value': ''
                    }],
                'exceptions': [],
                'class': 'Mim.Announcement',
                'options': {
                    'mimPath': 'mims/en-us/exceptions/FinalNM-EvenMoreNM.mim',
                    'getPromptData': () => {
                        return {};
                    }
                }
            };
        },
        '4a745911-a5a6-455e-ab29-d1d76d6f01e4': function () {
            return {
                'id': '4a745911-a5a6-455e-ab29-d1d76d6f01e4',
                'name': 'SSA - Happy',
                'transitions': [{
                        'frm': '4a745911-a5a6-455e-ab29-d1d76d6f01e4',
                        'to': '9280d6d3-91ab-4813-9ab5-401ab5592fc8',
                        'value': ''
                    }],
                'exceptions': [],
                'class': 'Flow.Eval-Async',
                'options': {
                    'exec': done => {
                        blackboard.speechDelegate.speak({ text: '<es cat="happy"/>.' }).then(done).catch(done);
                    },
                    'onStop': () => {
                        if (blackboard.speechDelegate) {
                            blackboard.speechDelegate.stop();
                        }
                    }
                }
            };
        },
        'd2eebf5f-b2a5-4b6f-99fe-97504bb3ef83': function () {
            return {
                'id': 'd2eebf5f-b2a5-4b6f-99fe-97504bb3ef83',
                'name': 'Display Text',
                'transitions': [{
                        'frm': 'd2eebf5f-b2a5-4b6f-99fe-97504bb3ef83',
                        'to': '1d0ca37e-be3c-4c33-af53-98bc012045a2',
                        'value': ''
                    }],
                'exceptions': [],
                'class': 'Flow.Eval',
                'options': {
                    'Script': () => {
                        blackboard.showInputText();
                    }
                }
            };
        },
        '02ae347b-f1ff-4d2b-a1cc-e65eb17fdabc': function () {
            return {
                'id': '02ae347b-f1ff-4d2b-a1cc-e65eb17fdabc',
                'name': 'Hide Text',
                'transitions': [{
                        'frm': '02ae347b-f1ff-4d2b-a1cc-e65eb17fdabc',
                        'to': '28e365cb-3b40-4a5f-adec-e2ff27739d64',
                        'value': ''
                    }],
                'exceptions': [],
                'class': 'Flow.Eval',
                'options': {
                    'Script': () => {
                        blackboard.hideInputText();
                    }
                }
            };
        },
        '45a2e357-05c6-41b4-a475-4f47ab2d7c36': function () {
            return {
                'id': '45a2e357-05c6-41b4-a475-4f47ab2d7c36',
                'name': 'Keep words onscreen for a bit',
                'asset-pack': 'core',
                'transitions': [{
                        'frm': '45a2e357-05c6-41b4-a475-4f47ab2d7c36',
                        'to': '02ae347b-f1ff-4d2b-a1cc-e65eb17fdabc',
                        'value': ''
                    }],
                'exceptions': [],
                'class': 'TimeoutJs',
                'options': {
                    'getTime': () => {
                        return 1000;
                    }
                }
            };
        }
    };
};
},{}],63:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const MimManager_1 = require("./MimManager");
exports.MimManager = MimManager_1.default;
const ListenEvent_1 = require("./delegates/ListenEvent");
exports.ListenEvent = ListenEvent_1.default;

},{"./MimManager":52,"./delegates/ListenEvent":60}],64:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log_1 = require("../log");
exports.default = log_1.default.createChild('Mim');

},{"../log":49}],65:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const path = require("path");
const fs = require("fs");
const electron_1 = require("./utils/electron");
const flowCore = require("jibo-flow-core");
const Behavior_1 = require("./bt/Behavior");
const Decorator_1 = require("./bt/Decorator");
function warn(msg) {
    let stack = new Error().stack;
    stack = stack.split('\n').splice(3).join('\n');
    if (console.groupCollapsed) {
        console.groupCollapsed("%cDeprecation Warning: %c%s", "color:#614108;background:#fffbe6", "font-weight:normal;color:#614108;background:#fffbe6", msg);
        console.warn(stack);
        console.groupEnd();
    }
    else {
        console.warn("Deprecation Warning:", msg);
        console.warn(stack);
    }
}
function default_1(jibo) {
    Object.defineProperties(jibo.utils, {
        SerialTimer: {
            get: function () {
                warn("jibo.utils.SerialTimer has moved, please use jibo.utils.perf.SerialTimer");
                return jibo.utils.perf.SerialTimer;
            }
        },
        ParallelTimer: {
            get: function () {
                warn("jibo.utils.ParallelTimer has moved, please use jibo.utils.perf.ParallelTimer");
                return jibo.utils.perf.ParallelTimer;
            }
        }
    });
    const RuntimePrototype = jibo.Runtime.prototype;
    RuntimePrototype.initOutput = function (service) {
        warn('jibo.initOutput is deprecated, used jibo.animUtils.initOutput');
        this.animUtils.initOutput(service);
    };
    RuntimePrototype.attachOutput = function () {
        warn('jibo.attachOutput is deprecated, used jibo.animUtils.attachOutput');
        this.animUtils.attachOutput();
    };
    RuntimePrototype.detachOutput = function () {
        warn('jibo.detachOutput is deprecated, used jibo.animUtils.detachOutput');
        this.animUtils.detachOutput();
    };
    RuntimePrototype.initAnimationUtilities = function (done, headless = false) {
        warn('jibo.initAnimationUtilities is deprecated, used jibo.animUtils.initUtilities');
        this.animUtils.initUtilities(done, headless);
    };
    Object.defineProperty(RuntimePrototype, 'FaceRenderer', {
        get: function () {
            warn('jibo.FaceRenderer is deprecated, please use jibo.rendering.FaceRenderer');
            return this.rendering.FaceRenderer;
        }
    });
    Object.defineProperty(RuntimePrototype, 'flowCore', {
        get: function () {
            warn('jibo.flowCore is deprecated, please use the jibo-flow-core module instead');
            return flowCore;
        }
    });
    Object.defineProperty(RuntimePrototype, "bodySettings", {
        get: function () {
            warn("jibo.bodySettings is deprecated, please use jibo.system");
            return this.system;
        }
    });
    Object.defineProperty(RuntimePrototype, "body", {
        get: function () {
            warn("jibo.body is deprecated, please use jibo.system");
            return this.system;
        }
    });
    Object.defineProperty(RuntimePrototype, "audio", {
        get: function () {
            warn("jibo.audio is deprecated, please use jibo.system");
            return this.system;
        }
    });
    RuntimePrototype.requireAssetPack = function (assetPackPackage) {
        warn('jibo.requireAssetPack is deprecated');
        if (fs.existsSync(assetPackPackage)) {
            const project = require(assetPackPackage);
            if (project.jibo && project.jibo.type === "asset-pack") {
                const uri = path.resolve(path.parse(assetPackPackage).dir, project.main);
                return require(uri);
            }
        }
    };
    const PathUtils = jibo.utils.PathUtils;
    PathUtils.getBaseDirectory = function (dir, callback) {
        warn("PathUtils.getBaseDirectory is deprecated, please use PathUtils.findRoot(dir)");
        const base = PathUtils.findRoot(dir);
        callback(base, PathUtils.getProjectName(base));
    };
    PathUtils.getProjectRoot = function (callback) {
        warn("PathUtils.getProjectRoot is deprecated, please use PathUtils.findRoot()");
        PathUtils.getBaseDirectory(process.cwd(), callback);
    };
    const kb = jibo.services.kb;
    const ModelPrototype = kb.Model.prototype;
    ModelPrototype.loadList = function (ids, callback) {
        warn('kb.Model.loadList is deprecated, please use kb.Model.load');
        return this.load(ids, callback);
    };
    ModelPrototype.fetchList = function (ids, quietly = false) {
        warn('kb.Model.fetchList is deprecated, please use kb.Model.fetch');
        return this.fetch(ids, quietly);
    };
    if (!electron_1.default) {
        return;
    }
    const globalJibo = global.JIBO = {};
    const Factory = jibo.bt.Factory;
    const FaceRenderer = jibo.rendering.FaceRenderer;
    const ViewManager = jibo.rendering.gui.ViewManager;
    const TRANSITION = jibo.rendering.gui.TRANSITION;
    const STATE = jibo.rendering.gui.views.STATE;
    const CATEGORY = jibo.rendering.gui.views.CATEGORY;
    const GESTURE = jibo.rendering.gui.GESTURE;
    const STACK_DIRECTION = jibo.rendering.gui.STACK_DIRECTION;
    const View = jibo.rendering.gui.views.View;
    Object.defineProperty(globalJibo, "bt", {
        get: function () {
            warn("JIBO.bt has moved, please use jibo.bt");
            return jibo.bt;
        }
    });
    Object.defineProperty(jibo.flow.FlowExecutorFactory.prototype, 'flowObjects', {
        get: function () {
            warn("jibo.flow.flowObjects has moved, please use jibo.flow.core");
            return jibo.flow.core;
        }
    });
    Object.defineProperty(Factory.prototype, "factory", {
        get: function () {
            warn("jibo.bt.factory is deprecated, please use jibo.bt");
            return this;
        }
    });
    Object.defineProperty(jibo.bt.BehaviorTree.prototype, "status", {
        get: function () {
            warn('BehaviorTree.status is deprecated, please use BehaviorTree.currentStatus');
            return this.currentStatus;
        }
    });
    Object.defineProperty(ViewManager.prototype, "UP", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.UP is deprecated, please use jibo.face.views.TRANSITION.UP');
            return TRANSITION.UP;
        }
    });
    Object.defineProperty(ViewManager.prototype, "DOWN", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.DOWN is deprecated, please use jibo.face.views.TRANSITION.DOWN');
            return TRANSITION.DOWN;
        }
    });
    Object.defineProperty(ViewManager.prototype, "RIGHT", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.RIGHT is deprecated, please use jibo.face.views.TRANSITION.RIGHT');
            return TRANSITION.RIGHT;
        }
    });
    Object.defineProperty(ViewManager.prototype, "LEFT", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.LEFT is deprecated, please use jibo.face.views.TRANSITION.LEFT');
            return TRANSITION.LEFT;
        }
    });
    Object.defineProperty(ViewManager.prototype, "IN", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.IN is deprecated, please use jibo.face.views.TRANSITION.IN');
            return TRANSITION.IN;
        }
    });
    Object.defineProperty(ViewManager.prototype, "OUT", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.OUT is deprecated, please use jibo.face.views.TRANSITION.OUT');
            return TRANSITION.OUT;
        }
    });
    Object.defineProperty(ViewManager.prototype, "NONE", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.NONE is deprecated, please use jibo.face.views.TRANSITION.NONE');
            return TRANSITION.NONE;
        }
    });
    Object.defineProperty(jibo.rendering.gui.ViewManager, "TRANS_UP", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.TRANS_UP is deprecated, please use jibo.face.views.TRANSITION.UP');
            return TRANSITION.UP;
        }
    });
    Object.defineProperty(jibo.rendering.gui.ViewManager, "TRANS_DOWN", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.TRANS_DOWN is deprecated, please use jibo.face.views.TRANSITION.DOWN');
            return TRANSITION.DOWN;
        }
    });
    Object.defineProperty(jibo.rendering.gui.ViewManager, "TRANS_RIGHT", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.TRANS_RIGHT is deprecated, please use jibo.face.views.TRANSITION.RIGHT');
            return TRANSITION.RIGHT;
        }
    });
    Object.defineProperty(jibo.rendering.gui.ViewManager, "TRANS_LEFT", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.TRANS_LEFT is deprecated, please use jibo.face.views.TRANSITION.LEFT');
            return TRANSITION.LEFT;
        }
    });
    Object.defineProperty(jibo.rendering.gui.ViewManager, "TRANS_IN", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.TRANS_IN is deprecated, please use jibo.face.views.TRANSITION.IN');
            return TRANSITION.IN;
        }
    });
    Object.defineProperty(jibo.rendering.gui.ViewManager, "TRANS_EYE", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.TRANS_EYE is deprecated, please use jibo.face.views.TRANSITION.EYE');
            return TRANSITION.EYE;
        }
    });
    Object.defineProperty(jibo.rendering.gui.ViewManager, "TRANS_OUT", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.TRANS_OUT is deprecated, please use jibo.face.views.TRANSITION.OUT');
            return TRANSITION.OUT;
        }
    });
    Object.defineProperty(jibo.rendering.gui.ViewManager, "TRANS_NONE", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.TRANS_NONE is deprecated, please use jibo.face.views.TRANSITION.NONE');
            return TRANSITION.NONE;
        }
    });
    Object.defineProperty(jibo.rendering.gui.ViewManager, "NONE", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.NONE is deprecated, please use jibo.face.views.TRANSITION.NONE');
            return TRANSITION.NONE;
        }
    });
    Object.defineProperty(ViewManager.prototype, "INITIALIZED", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.INITIALIZED is deprecated, please use jibo.face.views.STATE.INITIALIZED');
            return STATE.INITIALIZED;
        }
    });
    Object.defineProperty(ViewManager.prototype, "DATA_LOADED", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.DATA_LOADED is deprecated, please use jibo.face.views.STATE.DATA_LOADED');
            return STATE.DATA_LOADED;
        }
    });
    Object.defineProperty(ViewManager.prototype, "ASSETS_LOADED", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.ASSETS_LOADED is deprecated, please use jibo.face.views.STATE.ASSETS_LOADED');
            return STATE.ASSETS_LOADED;
        }
    });
    Object.defineProperty(ViewManager.prototype, "LOADED", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.LOADED is deprecated, please use jibo.face.views.STATE.LOADED');
            return STATE.LOADED;
        }
    });
    Object.defineProperty(ViewManager.prototype, "OPENED", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.OPENED is deprecated, please use jibo.face.views.STATE.OPENED');
            return STATE.OPENED;
        }
    });
    Object.defineProperty(ViewManager.prototype, "CLOSED", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.CLOSED is deprecated, please use jibo.face.views.STATE.CLOSED');
            return STATE.CLOSED;
        }
    });
    Object.defineProperty(ViewManager.prototype, "CATEGORY_GUI", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.CATEGORY_GUI is deprecated, please use jibo.face.views.CATEGORY.GUI');
            return CATEGORY.GUI;
        }
    });
    Object.defineProperty(ViewManager.prototype, "CATEGORY_DISPLAY", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.CATEGORY_DISPLAY is deprecated, please use jibo.face.views.CATEGORY.DISPLAY');
            return CATEGORY.DISPLAY;
        }
    });
    Object.defineProperty(ViewManager.prototype, "CATEGORY_EYE", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.CATEGORY_EYE is deprecated, please use jibo.face.views.CATEGORY.EYE');
            return CATEGORY.EYE;
        }
    });
    Object.defineProperty(ViewManager.prototype, "TAP", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.TAP is deprecated, please use jibo.face.views.GESTURE.TAP');
            return GESTURE.TAP;
        }
    });
    Object.defineProperty(ViewManager.prototype, "SWIPE", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.SWIPE is deprecated, please use jibo.face.views.GESTURE.SWIPE_DOWN');
            return GESTURE.SWIPE_DOWN;
        }
    });
    Object.defineProperty(ViewManager.prototype, "STACK_ADD", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.STACK_ADD is deprecated, please use jibo.face.views.STACK_DIRECTION.ADD');
            return STACK_DIRECTION.ADD;
        }
    });
    Object.defineProperty(ViewManager.prototype, "STACK_REMOVE", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.STACK_REMOVE is deprecated, please use jibo.face.views.STACK_DIRECTION.REMOVE');
            return STACK_DIRECTION.REMOVE;
        }
    });
    Object.defineProperty(ViewManager.prototype, "STACK_SWAP", {
        get: function () {
            warn('jibo.rendering.gui.ViewManager.STACK_SWAP is deprecated, please use jibo.face.views.STACK_DIRECTION.SWAP');
            return STACK_DIRECTION.SWAP;
        }
    });
    ViewManager.prototype.closeAll = function (onClosedAll, openTransition, closeTransition) {
        warn('jibo.face.views.closeAll is deprecated, please use:' +
            ' jibo.face.views.changeView({removeAll:true, closeTransition:closeTransition}, onClosedAll)');
        const config = {
            removeAll: true,
            openTransition: openTransition,
            closeTransition: closeTransition
        };
        this.changeView(config, onClosedAll);
    };
    ViewManager.prototype.closeAllThenAdd = function (viewDeterminer, onAdded, openTransition, closeTransition) {
        warn('jibo.face.views.closeAllThenAdd is deprecated, please use:' +
            ' jibo.face.views.changeView({removeAll:true, add:viewDeterminer, openTransition:openTransition, closeTransition:closeTransition}, onAdded)');
        const config = {
            removeAll: true,
            addView: viewDeterminer,
            openTransition: openTransition,
            closeTransition: closeTransition
        };
        this.changeView(config, onAdded);
    };
    ViewManager.prototype.closeAllLeaveEmpty = function (onClosedAll, closeTransition) {
        warn('jibo.face.views.closeAllLeaveEmpty is deprecated, please use:' +
            ' jibo.face.views.changeView({removeAll:true, leaveEmpty:true, closeTransition:closeTransition}, onClosedAll)');
        const config = {
            removeAll: true,
            leaveEmpty: true,
            closeTransition: closeTransition
        };
        this.changeView(config, onClosedAll);
    };
    ViewManager.prototype.removeViewLeaveEmpty = function (onRemoved, closeTransition, onFailure) {
        warn('jibo.face.views.removeViewLeaveEmpty is deprecated, please use' +
            ' jibo.face.views.changeView({remove:true, leaveEmpty:true, closeTransition:closeTransition}, onRemoved, onFailure)');
        const config = {
            remove: true,
            leaveEmpty: true,
            closeTransition: closeTransition
        };
        this.changeView(config, onRemoved, onFailure);
    };
    ViewManager.prototype.removeAllThenAdd = function (view, onAdded, openTransition, closeTransition, onFailure) {
        warn('jibo.face.views.removeAllThenAdd is deprecated, please use' +
            ' jibo.face.views.changeView({removeAll:true, add:view, openTransition:openTransition, closeTransition:closeTransition}, onAdded, onFailure)');
        const config = {
            removeAll: true,
            addView: view,
            openTransition: openTransition,
            closeTransition: closeTransition
        };
        this.changeView(config, onAdded, onFailure);
    };
    ViewManager.prototype.removeAllLeaveEmpty = function (onClosedAll, closeTransition, onFailure) {
        warn('jibo.face.views.removeAllLeaveEmpty is deprecated, please use' +
            ' jibo.face.views.changeView({removeAll:true, leaveEmpty:true, closeTransition:closeTransition}, onClosedAll, onFailure)');
        const config = {
            removeAll: true,
            leaveEmpty: true,
            closeTransition: closeTransition
        };
        this.changeView(config, onClosedAll, onFailure);
    };
    ViewManager.prototype.removeAll = function (onClosedAll, openTransition, closeTransition, onFailure) {
        warn('jibo.face.views.removeAll is deprecated, please use' +
            ' jibo.face.views.changeView({removeAll:true, openTransition:openTransition, closeTransition:closeTransition}, onClosedAll, onFailure)');
        const config = {
            removeAll: true,
            openTransition: openTransition,
            closeTransition: closeTransition
        };
        this.changeView(config, onClosedAll, onFailure);
    };
    Object.defineProperty(jibo.rendering.gui.TouchManager, "TAP", {
        get: function () {
            warn('jibo.rendering.gui.TouchManager.TAP is deprecated, please use jibo.face.views.GESTURE.TAP');
            return GESTURE.TAP;
        }
    });
    Object.defineProperty(jibo.rendering.gui.TouchManager, "SWIPE", {
        get: function () {
            warn('jibo.rendering.gui.TouchManager.SWIPE is deprecated, please use jibo.face.views.GESTURE.SWIPE_DOWN');
            return GESTURE.SWIPE_DOWN;
        }
    });
    Object.defineProperty(jibo.rendering.gui.TouchManager, "PAN", {
        get: function () {
            warn('jibo.rendering.gui.TouchManager.PAN is deprecated, please use jibo.face.views.GESTURE.PAN');
            return GESTURE.PAN;
        }
    });
    Object.defineProperty(jibo.rendering.gui.views.View.prototype, "swipeDownActions", {
        get: function () {
            warn('jibo.rendering.gui.View.swipeDownActions get is deprecated, ' +
                'use jibo.face.views.View.getActions(jibo.face.views.SWIPE_DOWN)');
            return this.getActions('swipeDown');
        },
        set: function (actions) {
            warn('jibo.rendering.gui.View.swipeDownActions set is deprecated, ' +
                'use jibo.face.views.View.addAction(ActionData|string, Object|null, false, false, jibo.face.views.SWIPE_DOWN) for each action');
            if (actions.length > 0) {
                for (let i = 0; i < actions.length; i++) {
                    this.addAction(actions[i], null, (i === 0), false, 'swipeDown');
                }
            }
            else {
                this.clearActions('swipeDown');
            }
        },
        enumerable: true
    });
    View.prototype.setupScreenClick = function () {
        warn("Views.setupScreenClick is deprecated and no longer necessary, just use addAction and specify 'tap' as the gesture");
    };
    Object.defineProperty(jibo.rendering.gui.views.View, "INITIALIZED", {
        get: function () {
            warn('jibo.rendering.gui.views.View.INITIALIZED is deprecated, please use jibo.face.views.STATE.INITIALIZED');
            return STATE.INITIALIZED;
        }
    });
    Object.defineProperty(jibo.rendering.gui.views.View, "DATA_LOADED", {
        get: function () {
            warn('jibo.rendering.gui.views.View.DATA_LOADED is deprecated, please use jibo.face.views.STATE.DATA_LOADED');
            return STATE.DATA_LOADED;
        }
    });
    Object.defineProperty(jibo.rendering.gui.views.View, "ASSETS_LOADED", {
        get: function () {
            warn('jibo.rendering.gui.views.View.ASSETS_LOADED is deprecated, please use jibo.face.views.STATE.ASSETS_LOADED');
            return STATE.ASSETS_LOADED;
        }
    });
    Object.defineProperty(jibo.rendering.gui.views.View, "LOADED", {
        get: function () {
            warn('jibo.rendering.gui.views.View.LOADED is deprecated, please use jibo.face.views.STATE.LOADED');
            return STATE.LOADED;
        }
    });
    Object.defineProperty(jibo.rendering.gui.views.View, "OPENED", {
        get: function () {
            warn('jibo.rendering.gui.views.View.OPENED is deprecated, please use jibo.face.views.STATE.OPENED');
            return STATE.OPENED;
        }
    });
    Object.defineProperty(jibo.rendering.gui.views.View, "CLOSED", {
        get: function () {
            warn('jibo.rendering.gui.views.View.CLOSED is deprecated, please use jibo.face.views.STATE.CLOSED');
            return STATE.CLOSED;
        }
    });
    Object.defineProperty(jibo.rendering.gui.views.View, "DESTROYED", {
        get: function () {
            warn('jibo.rendering.gui.views.View.DESTROYED is deprecated, please use jibo.face.views.STATE.DESTROYED');
            return STATE.DESTROYED;
        }
    });
    Object.defineProperty(jibo.rendering.gui.views.View, "LOAD_ERROR", {
        get: function () {
            warn('jibo.rendering.gui.views.View.LOAD_ERROR is deprecated, please use jibo.face.views.STATE.LOAD_ERROR');
            return STATE.LOAD_ERROR;
        }
    });
    Object.defineProperty(jibo.rendering.gui.views.View, "CATEGORY_GUI", {
        get: function () {
            warn('jibo.rendering.gui.views.View.CATEGORY_GUI is deprecated, please use jibo.face.views.CATEGORY.GUI');
            return CATEGORY.GUI;
        }
    });
    Object.defineProperty(jibo.rendering.gui.views.View, "CATEGORY_DISPLAY", {
        get: function () {
            warn('jibo.rendering.gui.views.View.CATEGORY_DISPLAY is deprecated, please use jibo.face.views.CATEGORY.DISPLAY');
            return CATEGORY.DISPLAY;
        }
    });
    Object.defineProperty(jibo.rendering.gui.views.View, "CATEGORY_EYE", {
        get: function () {
            warn('jibo.rendering.gui.views.View.CATEGORY_EYE is deprecated, please use jibo.face.views.CATEGORY.EYE');
            return CATEGORY.EYE;
        }
    });
    Factory.prototype.addBehavior = function (mod, namespace) {
        warn("Factory.addBehavior is deprecated, please use jibo.bt.register");
        namespace = namespace || "";
        const name = path.parse(mod.filename).name
            .replace(/[^\d\w]/g, ' ')
            .toLowerCase()
            .replace(/(?:^|\s)(\w)/g, (matches, letter) => {
            return letter.toUpperCase();
        });
        this.register(name, namespace, mod.exports);
    };
    Factory.prototype.createBehavior = function (object) {
        warn("jibo.bt.createBehavior is deprecated, please extend from jibo.bt.Behavior and use jibo.bt.register");
        return newBehavior(object);
    };
    Factory.prototype.createDecorator = function (object) {
        warn("jibo.bt.createDecorator is deprecated, please extend from jibo.bt.Decorator and use jibo.bt.register");
        return newDecorator(object);
    };
    function newBehavior(config) {
        config = Object.assign({
            constructor: function () { },
            start: function () { return true; },
            update: function () { return this.currentStatus; },
            stop: function () { }
        }, config);
        class NewElement extends Behavior_1.default {
            constructor(options) {
                super(options);
                for (let method in config) {
                    if (method === "constructor") {
                        continue;
                    }
                    if (typeof config[method] === "function") {
                        this[method] = config[method];
                    }
                }
                config.constructor.call(this, options);
            }
            update() {
                return config.update.call(this);
            }
        }
        return NewElement;
    }
    function newDecorator(config) {
        config = Object.assign({
            constructor: function () { },
            start: function () { return true; },
            update: function (status) { return status; },
            stop: function () { }
        }, config);
        class NewElement extends Decorator_1.default {
            constructor(options) {
                super(options);
                for (let method in config) {
                    if (method === "constructor") {
                        continue;
                    }
                    if (method === "name") {
                        continue;
                    }
                    if (method === "namespace") {
                        continue;
                    }
                    this[method] = config[method];
                }
                config.constructor.call(this, options);
            }
            update(result) {
                return config.update.call(this, result);
            }
        }
        return NewElement;
    }
    Factory.prototype.registerBehavior = function (config) {
        warn("jibo.bt.registerBehavior is deprecated, please extend from jibo.bt.Behavior and use jibo.bt.register");
        let name = config.name;
        let namespace = config.namespace;
        let Constructor = newBehavior(config);
        this.register(name, namespace, Constructor);
        return Constructor;
    };
    Factory.prototype.registerDecorator = function (config) {
        warn("jibo.bt.registerDecorator is deprecated, please extend from jibo.bt.Decorator and use jibo.bt.register");
        let name = config.name;
        let namespace = config.namespace;
        let Constructor = newDecorator(config);
        this.register(name, namespace, Constructor);
        return Constructor;
    };
    jibo.bt.Behavior.prototype.setDecorators = function (decorators) {
        warn("Behavior.setDecorators is deprecated, please use Behavior.decorators setter, e.g. behavior.decorators = []");
        this.decorators = decorators;
        return this;
    };
    jibo.bt.Behavior.prototype.getName = function () {
        warn("Behavior.getName is deprecated, please use Behavior.name getter, e.g. behavior.name");
        return this.name;
    };
    jibo.bt.Behavior.prototype.setChildren = function (children) {
        warn("Behavior.setChildren is deprecated, please use Behavior.children setter, e.g. behavior.children = []");
        this.children = children;
    };
    FaceRenderer.prototype.setRenderOnlyWhenDirty = function () {
        warn("renderer.setRenderOnlyWhenDirty is deprecated and no required");
    };
    Object.defineProperty(FaceRenderer.prototype, "scene", {
        get: function () {
            let thiz = this;
            return {
                stop() {
                    warn("renderer.scene.stop() is deprecated, please use jibo.face.paused = true");
                    thiz.paused = true;
                },
                play() {
                    warn("renderer.scene.play() is deprecated, please use jibo.face.paused = false");
                    thiz.paused = false;
                }
            };
        }
    });
    jibo.utils.AudioUtils = {
        getPath: (fileName) => {
            warn("AudioUtils.getPath is deprecated, please use PathUtils.setDefaultPath('audio', fileName)");
            return PathUtils.setDefaultPath('audio', fileName);
        },
        startAudio: (audioPath, assetPack, cb) => {
            warn("AudioUtils.startAudio is deprecated, please use SoundUtils.playOnce(fileName, callback)");
            const uri = PathUtils.getAudioUri(audioPath, assetPack);
            jibo.sound.SoundUtils.playOnce(uri, cb);
            return audioPath;
        }
    };
    jibo.services.Media.prototype.getUrlById = function (id) {
        warn('Media.getUrlById is deprecated, please use Media.getUrl');
        return jibo.Runtime.instance.getUrl(id);
    };
    Object.defineProperties(jibo.rendering.animation.KeysAnimation.prototype, {
        setSpeed: {
            value: function (speed) {
                warn('KeysAnimation.setSpeed is deprecated, please use KeysAnimation.builder.setSpeed(speed)');
                return this._builder.setSpeed(speed);
            }
        },
        setNumLoops: {
            value: function (numLoops) {
                warn('KeysAnimation.setNumLoops is deprecated, please use KeysAnimation.builder.setNumLoops(numLoops)');
                this._builder.setNumLoops(numLoops);
            }
        },
        setDOFs: {
            value: function (dofNames) {
                warn('KeysAnimation.setDOFs is deprecated, please use KeysAnimation.builder.setDOFs(dofNames)');
                this._builder.setDOFs(dofNames);
            }
        },
        getDOFs: {
            value: function (dofNames) {
                warn('KeysAnimation.getDOFs is deprecated, please use KeysAnimation.builder.getDOFs()');
                return this._builder.getDOFs(dofNames);
            }
        },
        setPlayBounds: {
            value: function (inPoint, outPoint) {
                warn('KeysAnimation.setPlayBounds is deprecated, please use KeysAnimation.builder.setPlayBounds(inPoint, outPoint)');
                this._builder.setPlayBounds(inPoint, outPoint);
            }
        },
        getSourceAnimationDuration: {
            value: function () {
                warn('KeysAnimation.getSourceAnimationDuration is deprecated, please use KeysAnimation.builder.getSourceAnimationDuration()');
                return this._builder.getSourceAnimationDuration();
            }
        }
    });
    Object.defineProperty(RuntimePrototype, 'attention', {
        get: function () {
            throw new Error('jibo.attention has been removed, please use jibo.expression');
        }
    });
    Object.defineProperty(RuntimePrototype, 'dofArbiter', {
        get: function () {
            throw new Error('jibo.dofArbiter has been removed, please use jibo.expression');
        }
    });
    Object.defineProperty(jibo.services.GlobalEvents.prototype, "stop", {
        get: function () {
            warn("jibo.globalEvents.stop has been renamed to jibo.globalEvents.voiceStop");
            return jibo.Runtime.instance.globalEvents.voiceStop;
        }
    });
    Object.defineProperty(jibo.services.GlobalEvents.prototype, "touchOn", {
        get: function () {
            warn("jibo.globalEvents.touchOn has been renamed to jibo.globalEvents.touchStop");
            return jibo.Runtime.instance.globalEvents.touchStop;
        }
    });
}
exports.default = default_1;

},{"./bt/Behavior":3,"./bt/Decorator":7,"./utils/electron":205,"fs":undefined,"jibo-flow-core":undefined,"path":undefined}],66:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Status_1 = require("../bt/Status");
const Subtree_1 = require("../bt/behaviors/Subtree");
const Mim_1 = require("../bt/behaviors/Mim");
const Menu_1 = require("../bt/behaviors/Menu");
const log_1 = require("./log");
const path = require("path");
class ActivityImplementation {
    constructor(activity, flowExecutor, optionCodeThis) {
        this.activity = activity;
        this.flowExecutor = flowExecutor;
        this.name = activity.name;
        this.class = activity.class;
        this.assetPack = activity.assetPack;
        this.optionCodeThis = optionCodeThis;
        this.options = flowExecutor.context.getActivityOptions(activity.id, this.optionCodeThis);
        this.transitions = activity.transitions;
        this.exceptions = activity.exceptions;
        this.result = null;
        this.exceptionPayload = null;
    }
    start(context) { return true; }
    update(context) { return Status_1.default.SUCCEEDED; }
    stop(context) {
        return Promise.resolve();
    }
    destroy() { }
    formOrThrowException(jsexception) {
        let exception = '~Exception.' + jsexception.name;
        if (!this.flowExecutor.searchException(exception)) {
            throw jsexception;
        }
        return exception;
    }
    getResultAsString() {
        let activityResult = this.result;
        if (activityResult === undefined) {
            activityResult = '';
        }
        return String(activityResult);
    }
}
class FlowBegin extends ActivityImplementation {
}
class FlowNop extends ActivityImplementation {
}
class FlowBeginParallel extends ActivityImplementation {
}
class FlowWait extends ActivityImplementation {
    start() {
        this.startTime = Date.now();
        this.ms_to_pause = parseFloat(this.options.ms_to_pause);
        return true;
    }
    update() {
        let success = Date.now() - this.startTime >= this.ms_to_pause;
        return success ? Status_1.default.SUCCEEDED : Status_1.default.IN_PROGRESS;
    }
}
class FlowSubflow extends ActivityImplementation {
    update() {
        let subflow = typeof this.options.subflowId === typeof ''
            ? this.options.subflowId
            : this.options.subflowId();
        this.flowExecutor.enterProcedure(subflow, undefined, this.options.inputParameters());
        return Status_1.default.SUCCEEDED;
    }
}
class FlowEnd extends ActivityImplementation {
    update() {
        let transition = this.options.getTransition();
        if (transition === undefined) {
            transition = this.name || '';
        }
        this.flowExecutor.emitStoppingActivity();
        this.flowExecutor.returnFromProcedure(transition);
        return Status_1.default.SUCCEEDED;
    }
}
class FlowCatch extends ActivityImplementation {
    update() {
        if (typeof (this.options.getTransition) === 'function') {
            this.result = this.options.getTransition(this.optionCodeThis.in.name, this.optionCodeThis.in.payload);
        }
        return Status_1.default.SUCCEEDED;
    }
}
class FlowThrow extends ActivityImplementation {
    update() {
        this.result = this.name;
        this.exceptionPayload = this.options.getPayload && this.options.getPayload();
        return Status_1.default.SUCCEEDED;
    }
}
class FlowInterrupt extends ActivityImplementation {
    update() {
        let payload = this.options.getPayload && this.options.getPayload();
        this.flowExecutor.injectExceptionInPrimary(this.name, payload);
        this.result = '';
        return Status_1.default.SUCCEEDED;
    }
}
class FlowEval extends ActivityImplementation {
    update() {
        this.result = this.options.Script();
        return Status_1.default.SUCCEEDED;
    }
}
class FlowBehavior extends ActivityImplementation {
    constructor(activity, flowExecutor, behavior, optionCodeThis) {
        super(activity, flowExecutor, optionCodeThis);
        this.behavior = behavior;
    }
    start() {
        return this.behavior.start();
    }
    update() {
        return this.behavior.update(Status_1.default.IN_PROGRESS);
    }
    stop() {
        return this.behavior ? this.behavior.stop() : Promise.resolve();
    }
    destroy() {
        if (this.behavior) {
            this.behavior.destroy();
            this.behavior = null;
        }
    }
}
exports.FlowBehavior = FlowBehavior;
class FlowMim extends ActivityImplementation {
    constructor(activity, flowExecutor, optionCodeThis) {
        super(activity, flowExecutor, optionCodeThis);
        let options = this.options;
        this.activityClass = activity.class;
        if (options.mimId && !options.mimPath) {
            let env = flowExecutor.environment;
            options.mimPath = path.join('mims', env.language, options.mimId);
            if (!options.mimPath.endsWith('.mim')) {
                options.mimPath += '.mim';
            }
            if (!options.config) {
                options.config = {};
            }
            options.config.rulesPath = path.join('rules', env.language);
        }
        if (typeof options.getMimPath === 'function') {
            options.mimPath = options.getMimPath();
        }
        if (!options.innerOnSuccess) {
            options.innerOnSuccess = options.onSuccess || options.onResults;
        }
        let onSuccess = this.activityClass === 'Mim.Announcement'
            ? () => { }
            : (result) => {
                let firstGrammarTag = '';
                if (result.asrResults && result.asrResults.intent) {
                    firstGrammarTag = result.firstGrammarTag = result.asrResults.intent;
                    result.grammarResults = result.asrResults.entities;
                }
                let transition = options.innerOnSuccess(result);
                if (transition === undefined) {
                    transition = firstGrammarTag;
                }
                this.transition = transition;
            };
        options.onSuccess = onSuccess;
        if (!options.innerOnFailure) {
            options.innerOnFailure = options.onFailure;
        }
        let onFailure = (this.activityClass !== 'Mim.Question' && this.activityClass !== 'Mim')
            ? () => { }
            : (result) => {
                let exception = "~InteractionError." + result.state.lastResultState;
                result.exception = exception;
                let transition = options.innerOnFailure(result);
                if (transition === undefined) {
                    transition = exception;
                }
                this.transition = transition;
                return flowExecutor.searchException(transition) !== undefined;
            };
        options.onFailure = onFailure;
        options.assetPack = flowExecutor.assetPack;
        options.blackboard = flowExecutor.blackboard;
        options.emitter = flowExecutor.emitter;
        options.asrMetadata = {
            flowFile: flowExecutor.environment.currentFile,
            activityName: activity.name,
            activityId: activity.id
        };
        this.mim = new Mim_1.default(options);
    }
    start() {
        return this.mim.start();
    }
    update() {
        let status = this.mim.update();
        if (status !== Status_1.default.IN_PROGRESS) {
            if (status === Status_1.default.FAILED) {
                this.result = '~MimFailed';
            }
            else {
                this.result = this.transition;
            }
        }
        return status;
    }
    stop() {
        return this.mim ? this.mim.stop() : Promise.resolve();
    }
    destroy() {
        if (this.mim) {
            this.mim.destroy();
            this.mim = null;
        }
    }
}
exports.FlowMim = FlowMim;
class FlowSubtree extends ActivityImplementation {
    constructor(activity, flowExecutor, optionCodeThis) {
        super(activity, flowExecutor, optionCodeThis);
        if (!this.options.onInnerResult) {
            this.options.onInnerResult = this.options.onResult;
        }
        let onResult = (result) => {
            this.transition = this.options.onInnerResult(result);
        };
        this.options.onResult = onResult;
        this.options.assetPack = flowExecutor.assetPack;
        this.options.blackboard = flowExecutor.blackboard;
        this.options.emitter = flowExecutor.emitter;
        this.subtree = new Subtree_1.default(this.options);
    }
    start() {
        return this.subtree.start();
    }
    update() {
        let status = this.subtree.update();
        if (status !== Status_1.default.IN_PROGRESS) {
            this.result = this.transition;
        }
        return status;
    }
    stop() {
        return this.subtree ? this.subtree.stop() : Promise.resolve();
    }
    destroy() {
        if (this.subtree) {
            this.subtree.destroy();
            this.subtree = null;
        }
    }
}
exports.FlowSubtree = FlowSubtree;
class FlowEvalAsync extends ActivityImplementation {
    start() {
        this.isDone = false;
        try {
            this.options.exec((transition) => {
                if (!this.isDone) {
                    this.isDone = true;
                    this.result = transition;
                }
            });
        }
        catch (e) {
            if (!this.isDone) {
                this.isDone = true;
                this.exceptionPayload = e;
                this.result = this.formOrThrowException(e);
            }
        }
        return true;
    }
    update() {
        if (this.isDone) {
            return Status_1.default.SUCCEEDED;
        }
        return Status_1.default.IN_PROGRESS;
    }
    stop() {
        if (this.options.onStop) {
            return this.options.onStop() || Promise.resolve();
        }
        return Promise.resolve();
    }
}
exports.FlowEvalAsync = FlowEvalAsync;
class FlowMenu extends ActivityImplementation {
    constructor(activity, flowExecutor, optionCodeThis) {
        super(activity, flowExecutor, optionCodeThis);
        let options = this.options;
        if (!options.innerOnItemChosen) {
            options.innerOnItemChosen = options.onItemChosen;
            if (options.innerOnItemChosen.length === 2) {
                log_1.default.warn('Menu::onItemChosen signature has changed from (result, menu) => string to (result, menu, overrideMenuTransition) => string');
            }
        }
        let onItemChosen = (result, menu, overrideMenuTransition) => {
            let firstGrammarTag = '';
            if (result && result.intent) {
                firstGrammarTag = result.intent;
            }
            let transition = options.innerOnItemChosen(result, menu, overrideMenuTransition);
            if (transition === undefined) {
                transition = firstGrammarTag;
            }
            this.transition = transition;
        };
        options.onItemChosen = onItemChosen;
        if (!options.innerOnMenuClosed) {
            options.innerOnMenuClosed = options.onMenuClosed;
            if (options.innerOnMenuClosed.length === 3) {
                log_1.default.warn('Menu::onMenuClosed signature has changed from (wasTimeout, menu, exception) => string to (wasTimeout, menu, overrideMenuTransition, exception) => string');
            }
        }
        let onMenuClosed = (timedOut, menu, overrideMenuTransition) => {
            let exception = "~InteractionError." + (timedOut ? 'MenuTimeout' : 'MenuClosed');
            let transition = options.innerOnMenuClosed(timedOut, menu, overrideMenuTransition, exception);
            if (transition === undefined) {
                transition = exception;
            }
            this.transition = transition;
            return flowExecutor.searchException(transition) !== undefined;
        };
        options.onMenuClosed = onMenuClosed;
        options.assetPack = flowExecutor.assetPack;
        options.blackboard = flowExecutor.blackboard;
        options.emitter = flowExecutor.emitter;
        this.menu = new Menu_1.default(options);
    }
    start() {
        return this.menu.start();
    }
    update() {
        let status = this.menu.update();
        if (status !== Status_1.default.IN_PROGRESS) {
            this.result = this.transition;
            if (status === Status_1.default.FAILED) {
                this.result = this.transition = '~MenuFailed';
            }
        }
        return status;
    }
    stop() {
        return this.menu ? this.menu.stop() : Promise.resolve();
    }
    destroy() {
        if (this.menu) {
            this.menu.destroy();
            this.menu = null;
        }
    }
}
exports.FlowMenu = FlowMenu;
exports.FlowClasses = {
    FlowBegin,
    FlowBeginParallel,
    FlowInterrupt,
    FlowCatch,
    FlowEvalAsync,
    FlowNop,
    FlowWait,
    FlowSubflow,
    FlowSubtree,
    FlowEnd,
    FlowThrow,
    FlowEval,
    Mim: FlowMim,
    MimAnnouncement: FlowMim,
    MimOptionalResponse: FlowMim,
    MimQuestion: FlowMim,
    Menu: FlowMenu
};
exports.default = ActivityImplementation;

},{"../bt/Status":10,"../bt/behaviors/Menu":15,"../bt/behaviors/Mim":16,"../bt/behaviors/Subtree":24,"./log":74,"path":undefined}],67:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const ActivityImplementation_1 = require("./ActivityImplementation");
const Runtime_1 = require("../Runtime");
class ActivityImplementationFactory {
    static getImplementationOfActivity(activity, flowExecutor, optionCodeThis) {
        let implementation;
        optionCodeThis = optionCodeThis || {};
        let result = this.getActivityOrBehaviorConstructor(activity);
        if (result.isActivity) {
            implementation = this.getActivityClassInstance(result.constructor, activity, flowExecutor, optionCodeThis);
        }
        else {
            implementation = this.getBehaviorClassInstance(result.constructor, activity, flowExecutor, optionCodeThis);
        }
        this.logActivity(activity, flowExecutor);
        let environment = flowExecutor.context.notepad.FlowEnv;
        environment.currentActivity = implementation;
        environment.currentProcedure = flowExecutor.context.current_procedure;
        environment.currentFile = flowExecutor.context.current_procedure.uri;
        let payload = {
            timestamp: Date.now(),
            thread: flowExecutor.name,
            uri: flowExecutor.context.current_procedure.uri,
            id: implementation.activity.id,
            name: implementation.name,
            class: implementation.class
        };
        flowExecutor.emit('constructing-activity', payload);
        return implementation;
    }
    static getActivityOrBehaviorConstructor(activity) {
        let className = this.getActivityImplementationClassName(activity);
        let isActivity = true;
        let constructor;
        constructor = Runtime_1.default.instance.flow.getActivityConstructor(className, activity.assetPack);
        if (!constructor) {
            constructor = Runtime_1.default.instance.bt.getBehaviorConstructor(className, activity.assetPack);
            if (constructor) {
                isActivity = false;
            }
        }
        if (!constructor) {
            throw new Error(`No implementation found for activity type: "${activity.class}" in namespace "${activity.assetPack}"`);
        }
        return { isActivity: isActivity, constructor: constructor };
    }
    static getActivityImplementationClassName(activity) {
        return activity.class.replace(/[.-]/g, '');
    }
    static getBehaviorClassInstance(behaviorConstructor, activity, flowExecutor, optionCodeThis) {
        let behaviorOptions = Object.assign({
            name: activity.name,
            emitter: flowExecutor.emitter,
            blackboard: flowExecutor.blackboard,
            assetPack: flowExecutor.assetPack,
        }, flowExecutor.context.getActivityOptions(activity.id, optionCodeThis));
        let behavior = new behaviorConstructor(behaviorOptions);
        return new ActivityImplementation_1.FlowBehavior(activity, flowExecutor, behavior, optionCodeThis);
    }
    static getActivityClassInstance(activityConstructor, activity, flowExecutor, optionCodeThis) {
        return new activityConstructor(activity, flowExecutor, optionCodeThis);
    }
    static logActivity(activity, flowExecutor) {
        let name = activity.name ? `("${activity.name}") ` : '';
        flowExecutor.log(`jfe-Executing: ${activity.class} ${name}in ${flowExecutor.context.current_procedure.name}`);
    }
}
exports.default = ActivityImplementationFactory;

},{"../Runtime":1,"./ActivityImplementation":66}],68:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class Notepad {
    setTransition(transition) {
        this.context.current_activity.result = transition;
    }
    constructor(context, params, environment) {
        this.context = context;
        this.params = params;
        this.FlowEnv = environment;
    }
}
class Result {
    constructor() {
        this.transition = "";
    }
}
class Context {
    constructor(flowExecutor, parent, current_procedure, params, notepad) {
        this.flowExecutor = flowExecutor;
        this.parent = parent;
        this.current_procedure = current_procedure;
        this.asyncFlows = [];
        this.notepad = notepad || new Notepad(this, params, flowExecutor.environment);
        this.result = new Result();
        this.code = current_procedure.procedureConstructor(this.flowExecutor.blackboard, this.notepad, this.result, this.flowExecutor.emitter);
    }
    getActivityOptions(activityId, optionCodeThis) {
        if (!(activityId in this.code)) {
            throw new Error(`FlowExecutor: Cannot find activity ID ${activityId} in procedure ${this.current_procedure.name}`);
        }
        let codeBehind = this.code[activityId];
        let options;
        if (typeof codeBehind === 'function') {
            options = codeBehind.bind(optionCodeThis)().options;
        }
        else {
            options = Object.assign({}, codeBehind.options || {});
        }
        return options;
    }
}
class FlowExceptionInfo {
}
exports.FlowExceptionInfo = FlowExceptionInfo;
exports.default = Context;

},{}],69:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_plugins_1 = require("jibo-plugins");
class Environment {
    constructor(assetPack) {
        this.assetPack = assetPack;
        this.assetPack = assetPack;
        this.lastException = null;
        this.language = "en-us";
        this.projectRoot = jibo_plugins_1.PathUtils.findRoot();
    }
}
exports.default = Environment;

},{"jibo-plugins":undefined}],70:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const State_1 = require("./State");
const ActivityImplementationFactory_1 = require("./ActivityImplementationFactory");
const Context_1 = require("./Context");
const Context_2 = require("./Context");
const Status_1 = require("../bt/Status");
const events_1 = require("events");
const Environment_1 = require("./Environment");
const Runtime_1 = require("../Runtime");
const log_1 = require("./log");
class FlowExecutor extends events_1.EventEmitter {
    constructor(flowRoot, overrides) {
        super();
        this.context = null;
        this.primary = null;
        this.nextClonePid = 0;
        overrides = overrides || {};
        this.blackboard = overrides.blackboard || Runtime_1.default.instance.bt.getBlackboard();
        this.emitter = overrides.emitter || new events_1.EventEmitter();
        this.assetPack = overrides.assetPack || "";
        this.params = overrides.params || {};
        this.enableLogging = overrides.enableLogging || false;
        this.environment = overrides.environment || new Environment_1.default(this.assetPack);
        this.environment.flowOptions = overrides;
        this.setupName(overrides);
        this.preloadAnims();
        this.state = State_1.default.READY;
        if (flowRoot) {
            this.flowRoot = flowRoot;
            let payload = {
                timestamp: Date.now(),
                thread: this.name,
                uri: flowRoot.startUri
            };
            this.emit('constructing-flow-executor', payload);
            this.enterProcedure(flowRoot.startProcedureOrName, flowRoot.startUri, this.params);
        }
    }
    setupName(overrides) {
        FlowExecutor.InstanceCount++;
        let pid = 0;
        if (overrides.getNextPid) {
            pid = overrides.getNextPid();
        }
        this.name = (overrides.name || '') + `${pid}-`;
    }
    preloadAnims() {
        console.warn("preloading anim");
    }
    getNextPid() {
        return this.nextClonePid++;
    }
    update() {
        this.updateAsyncs(this.context);
        return this.updatePrimary();
    }
    updatePrimary() {
        let lastState;
        while (this.state !== lastState) {
            lastState = this.state;
            this.step();
            if (this.state === State_1.default.READY) {
                break;
            }
        }
        return this.state === State_1.default.EXITED;
    }
    step() {
        switch (this.state) {
            case State_1.default.READY: {
                let success = false;
                let current_activity = this.context.current_activity;
                try {
                    success = current_activity.start(this.context);
                }
                catch (e) {
                    current_activity.exceptionPayload = e;
                    current_activity.result = current_activity.formOrThrowException(e);
                }
                this.state = !success ? State_1.default.DONE : State_1.default.IN_PROGRESS;
                break;
            }
            case State_1.default.IN_PROGRESS: {
                let current_activity = this.context.current_activity;
                let status;
                try {
                    status = current_activity.update(this.context);
                }
                catch (e) {
                    current_activity.exceptionPayload = e;
                    current_activity.result = current_activity.formOrThrowException(e);
                    this.state = State_1.default.DONE;
                }
                if (this.state !== State_1.default.IN_PROGRESS) {
                }
                else if (status === Status_1.default.SUCCEEDED || status === Status_1.default.FAILED) {
                    this.state = State_1.default.DONE;
                    if (status === Status_1.default.FAILED && this.context.current_activity.result === null) {
                        this.context.current_activity.result = 'fail';
                    }
                }
                break;
            }
            case State_1.default.DONE: {
                this.state = State_1.default.READY;
                this.selectAndFollowTransition();
                break;
            }
        }
    }
    updateAsyncs(context) {
        if (context) {
            this.updateAsyncs(context.parent);
            for (let i = 0; i < context.asyncFlows.length; i++) {
                let flow = context.asyncFlows[i];
                if (flow.update()) {
                    context.asyncFlows.splice(i--, 1);
                }
            }
        }
    }
    start() {
        this.emit('start');
    }
    stop() {
        this.log('Stopped');
        this.state = State_1.default.PAUSED;
        const rtn = this.stopCurrentActivity();
        this.emit('stop');
        let payload = {
            timestamp: Date.now(),
            thread: this.name,
            uri: this.context.current_procedure.uri
        };
        this.emit('stopping-flow-executor', payload);
        return rtn;
    }
    finish() {
        this.log('Finished');
        this.emit('finished');
        this.emit('flow-executor-finished', {
            timestamp: Date.now(),
            thread: this.name,
            uri: this.context.current_procedure.relativeUri
        });
    }
    stopCurrentActivity() {
        return this.stopCurrentActivityInContext(this.context);
    }
    stopCurrentActivityInContext(context) {
        this.emitStoppingActivity();
        const current_activity = context.current_activity;
        const rtn = current_activity.stop(context);
        rtn.then(() => {
            current_activity.destroy();
        });
        return rtn;
    }
    destroy() {
        this.log('Destroyed');
        FlowExecutor.InstanceCount--;
        this.stopCurrentActivity();
        this.emit('destroy');
        let context = this.context;
        while (context !== null) {
            this.destroyAsyncFlows([context]);
            context = context.parent;
        }
        this.flowRoot = null;
    }
    destroyAsyncFlows(contexts) {
        for (let context of contexts) {
            for (let flow of context.asyncFlows) {
                flow.stop().then(() => {
                    flow.destroy();
                });
            }
            context.asyncFlows = [];
        }
    }
    stopAndDestroy() {
        return this.stop().catch(() => { }).then(() => {
            this.destroy();
        });
    }
    enterProcedure(procedureObjectOrName, currentUri, params) {
        if (currentUri === undefined) {
            currentUri = this.context.current_procedure.uri;
        }
        let currentProcedure = this.flowRoot.loadProcedure(currentUri, procedureObjectOrName);
        let payload = {
            timestamp: Date.now(),
            thread: this.name,
            uri: currentProcedure.uri
        };
        this.emit('entering-procedure', payload);
        params = params || {};
        this.context = new Context_1.default(this, this.context, currentProcedure, params);
        let beginActivity = currentProcedure.getBeginActivity();
        this.context.current_activity = ActivityImplementationFactory_1.default.getImplementationOfActivity(beginActivity, this);
        this.loadAsyncBegins();
    }
    loadAsyncBegins() {
        let asyncBegins = this.context.current_procedure.getAsyncBeginActivities();
        for (let asyncBegin of asyncBegins) {
            this.context.asyncFlows.push(this.clone(asyncBegin));
        }
    }
    clone(activity) {
        let flow = new this.constructor(undefined, this);
        flow.primary = this;
        flow.flowRoot = this.flowRoot;
        flow.context = new Context_1.default(flow, null, this.context.current_procedure, {}, this.context.notepad);
        flow.context.current_activity = ActivityImplementationFactory_1.default.getImplementationOfActivity(activity, flow);
        return flow;
    }
    emitStoppingActivity() {
        let payload = {
            timestamp: Date.now(),
            thread: this.name,
            uri: this.context.current_procedure.uri,
            id: this.context.current_activity.activity.id,
            name: this.context.current_activity.name,
            class: this.context.current_activity.class,
            result: this.context.current_activity.getResultAsString()
        };
        this.emit('stopping-activity', payload);
    }
    returnFromProcedure(transition) {
        this.log('jfe-Procedure-Return', transition, this.context.current_procedure.relativeUri);
        let payload = {
            timestamp: Date.now(),
            thread: this.name,
            uri: this.context.current_procedure.uri,
            result: transition
        };
        this.emit('returning-from-procedure', payload);
        this.destroyAsyncFlows([this.context]);
        let result = this.context.result;
        result.transition = transition;
        if (this.context.parent === null) {
            this.state = State_1.default.EXITED;
            this.result = result;
        }
        else {
            this.context = this.context.parent;
            if (this.context.current_activity.class !== "Flow.Subflow") {
                throw new Error("Returned from a subflow (to something besides a Flow.Subflow activity");
            }
            this.context.current_activity.result = this.context.current_activity.options.getTransition(result);
        }
    }
    selectAndFollowTransition() {
        let dfault = null;
        let selected = null;
        let activityResult = this.context.current_activity.getResultAsString();
        if (activityResult.startsWith('~')) {
            this.throwException(activityResult);
            return;
        }
        this.log('jfe-Transition: ', activityResult);
        for (let transition of this.context.current_activity.transitions) {
            if (transition.value === '') {
                dfault = transition;
            }
            if (activityResult === transition.value) {
                selected = transition;
                break;
            }
        }
        if (selected === null) {
            if (dfault === null) {
                let activity_type = this.context.current_activity.activity.class;
                let procedure = this.context.current_procedure.name;
                throw new Error(`Activity named "${this.context.current_activity.name}" of type ${activity_type}
                in procedure "${procedure}" with result: "${activityResult}" found no matching transition.`);
            }
            selected = dfault;
        }
        this.transitionTo(selected.to);
    }
    injectExceptionInPrimary(exception, payload) {
        this.primary.stopCurrentActivity();
        this.primary.state = State_1.default.DONE;
        this.primary.context.current_activity.result = exception;
        this.primary.context.current_activity.exceptionPayload = payload;
    }
    searchException(exception) {
        let context = this.context;
        let foundActivity;
        let abandonedContexts = [];
        outer: do {
            let exceptions = context.current_activity.exceptions
                .sort((a, b) => b.value.length - a.value.length);
            for (let transition of exceptions) {
                if (this.isExceptionMatch(exception, transition.value)) {
                    foundActivity = context.current_procedure.activities[transition.to];
                    break outer;
                }
            }
            let catches = Object.keys(context.current_procedure.activities)
                .map((a) => context.current_procedure.activities[a])
                .filter((a) => a.class === 'Flow.Catch')
                .sort((a, b) => b.name.length - a.name.length);
            for (let activity of catches) {
                if (this.isExceptionMatch(exception, activity.name)) {
                    foundActivity = activity;
                    break outer;
                }
            }
            abandonedContexts.push(context);
            context = context.parent;
        } while (context !== null);
        if (context !== null) {
            return {
                context: context,
                activity: foundActivity,
                abandonedContexts: abandonedContexts
            };
        }
    }
    getCurrentStackTrace() {
        let trace = [];
        let context = this.context;
        while (context !== null) {
            trace.push({ activity: context.current_activity, procedure: context.current_procedure });
            context = context.parent;
        }
        return trace;
    }
    getFlowExceptionInfo(exception) {
        let flowException = new Context_2.FlowExceptionInfo();
        flowException.name = exception;
        flowException.activity = this.context.current_activity;
        flowException.procedure = this.context.current_procedure;
        flowException.stackTrace = this.getCurrentStackTrace();
        flowException.payload = this.context.current_activity.exceptionPayload;
        return flowException;
    }
    throwException(exception) {
        this.log('jfe-Exception: ', exception);
        this.state = State_1.default.PAUSED;
        let found = this.searchException(exception);
        if (!found) {
            throw new Error(`Failed to find exception handler for ${exception}`);
        }
        let exceptionInfo = this.getFlowExceptionInfo(exception);
        this.environment.lastException = exceptionInfo;
        this.context.current_activity.result = exceptionInfo.name;
        const prevOut = this.context.current_activity.optionCodeThis.out;
        this.stopCurrentActivity().then(() => {
            this.context = found.context;
            this.context.current_activity = ActivityImplementationFactory_1.default.getImplementationOfActivity(found.activity, this, { in: prevOut || exceptionInfo, inTransition: exceptionInfo.name });
            this.state = State_1.default.READY;
        });
        this.destroyAsyncFlows(found.abandonedContexts);
        for (let context of found.abandonedContexts) {
            this.stopCurrentActivityInContext(context);
        }
    }
    isExceptionMatch(actual_exception, candidate_catch) {
        if (!candidate_catch || !candidate_catch.startsWith('~') ||
            !actual_exception || !actual_exception.startsWith('~')) {
            return false;
        }
        let trycatch = candidate_catch.replace('~', '~.').replace(/\.$/, '');
        let exception = actual_exception.replace('~', '~.').replace(/\.$/, '');
        if (!exception.startsWith('~')) {
            return false;
        }
        while (true) {
            if (exception === trycatch) {
                return true;
            }
            if (exception === '~') {
                break;
            }
            exception = exception.replace(/\.[^.]+$/, '');
        }
        return false;
    }
    transitionTo(to) {
        let nextActivityThis = {
            'in': this.context.current_activity.optionCodeThis.out,
            'inResult': this.context.current_activity.result,
            'inTransition': this.context.current_activity.getResultAsString()
        };
        log_1.default.debug(this.name, 'transitionTo', nextActivityThis);
        this.stopCurrentActivity();
        this.context.current_activity =
            ActivityImplementationFactory_1.default.getImplementationOfActivity(this.context.current_procedure.activities[to], this, nextActivityThis);
    }
    log(...args) {
        log_1.default.debug(this.name, ...args);
    }
}
FlowExecutor.InstanceCount = 0;
exports.default = FlowExecutor;

},{"../Runtime":1,"../bt/Status":10,"./ActivityImplementationFactory":67,"./Context":68,"./Environment":69,"./State":72,"./log":74,"events":undefined}],71:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const FlowExecutor_1 = require("./FlowExecutor");
const jibo_flow_core_1 = require("jibo-flow-core");
const Runtime_1 = require("../Runtime");
const callsite = require("callsite");
const path = require("path");
const Status_1 = require("../bt/Status");
const State_1 = require("./State");
const log_1 = require("./log");
class FlowExecutorFactory {
    static create(uri, overrides = {}) {
        let flowRoot = jibo_flow_core_1.FlowRootFactory.create(uri);
        let flowExecutor = overrides.flowExecutor || FlowExecutor_1.default;
        return new flowExecutor(flowRoot, overrides);
    }
    constructor(flow) {
        this._activities = {};
        Object.assign(this, flow);
        this.registerCore();
    }
    register(name, namespace, classRef) {
        let ns = this._activities[namespace];
        if (!ns) {
            ns = this._activities[namespace] = {};
        }
        ns[name] = classRef;
    }
    registerCore() {
        for (let name in this.activities) {
            this.register(name, 'core', this.activities[name]);
        }
    }
    getActivityConstructor(className, namespace) {
        let ns = this._activities[namespace || 'core'];
        if (ns) {
            return ns[className];
        }
    }
    create(uri, overrides = {}) {
        let flowProcedure;
        if (typeof uri === 'string') {
            let calleeDirname = callsite()[1].getFileName();
            flowProcedure = this.getFilePathFromCallee(calleeDirname, uri);
        }
        else {
            flowProcedure = uri;
        }
        let flowRoot = jibo_flow_core_1.FlowRootFactory.create(flowProcedure);
        let flowExecutor = overrides.flowExecutor || FlowExecutor_1.default;
        return new flowExecutor(flowRoot, overrides);
    }
    run(uri, overrides = {}, onFinishedCallback = null) {
        if (typeof (overrides) === "function") {
            onFinishedCallback = overrides;
            overrides = {};
        }
        let flowExecutor;
        try {
            flowExecutor = this.create(uri, overrides);
        }
        catch (e) {
            log_1.default.error('Could not start flow: ', e, `uri: ${uri}, notepad overridden: ${!!overrides.notepad}, blackboard overridden: ${!!overrides.blackboard}, emitter overridden: ${!!overrides.emitter}, assetPack: ${overrides.assetPack}, stopOnException: ${overrides.stopOnException}, enableLogging: ${overrides.enableLogging}, flowExecutor overridden: ${!!overrides.flowExecutor}`);
            throw e;
        }
        let isExited = flowExecutor.update();
        function doUpdate(elapsed) {
            if (!isExited) {
                try {
                    isExited = flowExecutor.update();
                }
                catch (e) {
                    if (overrides.stopOnException || overrides.harnesses) {
                        clearTimer();
                        throw e;
                    }
                    log_1.default.error('FlowExecutor caught exception during update:', e);
                    if (onFinishedCallback !== null) {
                        clearTimer();
                        flowExecutor.removeListener('stop', stopUpdate);
                        flowExecutor.stop();
                        flowExecutor.destroy();
                        let callback = onFinishedCallback;
                        onFinishedCallback = null;
                        callback(e, Status_1.default.FAILED);
                    }
                }
            }
            else {
                flowExecutor.finish();
                stopUpdate();
            }
        }
        function clearTimer() {
            Runtime_1.default.instance.timer.removeListener('update', doUpdate);
        }
        function stopUpdate() {
            clearTimer();
            if (onFinishedCallback) {
                let callback = onFinishedCallback;
                onFinishedCallback = null;
                callback(null, flowExecutor.state === State_1.default.EXITED ? Status_1.default.SUCCEEDED : Status_1.default.INTERRUPTED);
            }
        }
        function startUpdate() {
            clearTimer();
            Runtime_1.default.instance.timer.on('update', doUpdate);
        }
        flowExecutor.once('start', startUpdate);
        flowExecutor.once('stop', stopUpdate);
        flowExecutor.once('destroy', clearTimer);
        flowExecutor.start();
        return flowExecutor;
    }
    getFilePathFromCallee(calleeDirname, uri) {
        let filePath;
        uri = uri.substr(0, uri.lastIndexOf(path.parse(uri).ext));
        if (!path.isAbsolute(uri)) {
            if (calleeDirname.indexOf('file://') === 0) {
                calleeDirname = calleeDirname.substr(7);
            }
            filePath = path.join(calleeDirname, '..', uri);
        }
        else {
            filePath = uri;
        }
        return filePath;
    }
}
exports.default = FlowExecutorFactory;

},{"../Runtime":1,"../bt/Status":10,"./FlowExecutor":70,"./State":72,"./log":74,"callsite":undefined,"jibo-flow-core":undefined,"path":undefined}],72:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var State;
(function (State) {
    State[State["IN_PROGRESS"] = 0] = "IN_PROGRESS";
    State[State["DONE"] = 1] = "DONE";
    State[State["READY"] = 2] = "READY";
    State[State["EXITED"] = 3] = "EXITED";
    State[State["PAUSED"] = 4] = "PAUSED";
})(State || (State = {}));
exports.default = State;

},{}],73:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const FlowExecutorFactory_1 = require("./FlowExecutorFactory");
exports.FlowExecutorFactory = FlowExecutorFactory_1.default;
const FlowExecutor_1 = require("./FlowExecutor");
exports.FlowExecutor = FlowExecutor_1.default;
const ActivityImplementation_1 = require("./ActivityImplementation");
exports.ActivityImplementation = ActivityImplementation_1.default;
const ActivityImplementation_2 = require("./ActivityImplementation");
const jibo_flow_core_1 = require("jibo-flow-core");
exports.Activity = jibo_flow_core_1.Activity;
exports.Procedure = jibo_flow_core_1.Procedure;
exports.FlowRootFactory = jibo_flow_core_1.FlowRootFactory;
const Context_1 = require("./Context");
exports.FlowExceptionInfo = Context_1.FlowExceptionInfo;
const core = require("jibo-flow-core");
exports.core = core;
const State_1 = require("./State");
exports.State = State_1.default;
let activities = ActivityImplementation_2.FlowClasses;
exports.activities = activities;

},{"./ActivityImplementation":66,"./Context":68,"./FlowExecutor":70,"./FlowExecutorFactory":71,"./State":72,"jibo-flow-core":undefined}],74:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log_1 = require("../log");
exports.default = log_1.default.createChild('Flow');

},{"../log":75}],75:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_log_1 = require("jibo-log");
exports.default = new jibo_log_1.Log('Jibo');

},{"jibo-log":undefined}],76:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const action = require("jibo-action-system");
const Runtime_1 = require("../Runtime");
class ActionPlugin {
    constructor() {
        this.api = action.api;
    }
    init(done) {
        const jibo = Runtime_1.default.instance;
        if (jibo.runMode === jibo.RunMode.UNIT_TESTS) {
            return done();
        }
        action.api.init({ jibo })
            .then(() => done())
            .catch(e => done(e));
    }
}
Runtime_1.default.registerPlugin(ActionPlugin, 'action', {
    depends: ['expression', 'services', 'anim-db'],
    api: true,
    name: 'action'
});
exports.default = ActionPlugin;

},{"../Runtime":1,"jibo-action-system":undefined}],77:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const animdb = require("jibo-anim-db");
const Runtime_1 = require("../Runtime");
const log_1 = require("../log");
class AnimDBPlugin {
    constructor() {
        this.api = animdb.api;
    }
    init(done) {
        const jibo = Runtime_1.default.instance;
        let promise;
        const animDBPath = animdb.api.resolveAnimDB(jibo);
        if (!animDBPath) {
            log_1.default.warn(`Module 'jibo-anim-db-animations' not found. AnimDB plugin will not contain animations.`);
            promise = animdb.api.init(jibo);
        }
        else {
            promise = animdb.api.init(jibo, animDBPath);
        }
        promise.then(() => done())
            .catch(err => {
            log_1.default.error(`Error parsing AnimDB at path: '${animDBPath}':`, err);
            done();
        });
    }
}
Runtime_1.default.registerPlugin(AnimDBPlugin, 'anim-db', {
    depends: ['expression'],
    api: true,
    name: 'animDB'
});
exports.default = AnimDBPlugin;

},{"../Runtime":1,"../log":75,"jibo-anim-db":undefined}],78:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../Runtime");
class AutobotPlugin {
    constructor() {
    }
    init(done) {
        done(null, this);
    }
    executeCommand(command) {
        const jibo = Runtime_1.default.instance;
        if (!jibo['dev-shell'] || !jibo['dev-shell']._client) {
            return;
        }
        process.nextTick(() => {
            const client = jibo['dev-shell']._client;
            try {
                let result = eval(command.script);
                client.send({
                    command: 'execute-result',
                    result,
                    id: command.id,
                    success: true
                });
            }
            catch (error) {
                client.send({
                    command: 'execute-result',
                    id: command.id,
                    error: error.toString(),
                    success: false
                });
            }
        });
    }
    log(...args) {
        const jibo = Runtime_1.default.instance;
        if (!jibo['dev-shell'] || !jibo['dev-shell']._client) {
            return;
        }
        const client = jibo['dev-shell']._client;
        client.send({
            command: 'autobot-log',
            data: args
        });
    }
}
Runtime_1.default.registerPlugin(AutobotPlugin, 'autobot', {
    depends: ['services'],
    api: true,
    name: 'autobot'
});
exports.default = AutobotPlugin;

},{"../Runtime":1}],79:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
const jibo_client_framework_1 = require("jibo-client-framework");
const Runtime_1 = require("../Runtime");
const log_1 = require("../log");
const log = log_1.default.createChild('DevShellPlugin');
class DevShellPlugin extends events_1.EventEmitter {
    constructor() {
        super();
    }
    init(done) {
        const jibo = Runtime_1.default.instance;
        jibo.systemManager.getMode((err, mode) => {
            if (mode === 'int-developer' ||
                mode === 'developer' ||
                jibo.runMode === jibo.RunMode.SIMULATOR) {
                log.info('Initializing DevShellPlugin...');
                const records = jibo.records;
                for (let i = 0; i < records.length; i++) {
                    let record = records[i];
                    if (record.name === 'dev-shell') {
                        this._devShellPortHost = `ws://127.0.0.1:${record.port}`;
                        break;
                    }
                }
                if (!this._devShellPortHost) {
                    done(new Error(`dev-shell service is down, even though mode is ${mode}`));
                }
                this._client = new jibo_client_framework_1.WSClient(this._devShellPortHost);
                this._client.on('message', this.onMessage.bind(this));
                done();
            }
            else {
                done();
            }
        });
        this.once('init', done);
    }
    onMessage(command) {
        if (command.command === 'execute') {
            Runtime_1.default.instance.autobot.executeCommand(command);
        }
    }
}
Runtime_1.default.registerPlugin(DevShellPlugin, 'dev-shell', {
    api: true,
    depends: ['service-records']
});
exports.default = DevShellPlugin;

},{"../Runtime":1,"../log":75,"events":undefined,"jibo-client-framework":undefined}],80:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const embodied = require("jibo-embodied-dialog");
const Runtime_1 = require("../Runtime");
const log_1 = require("../log");
class EmbodiedPlugin {
    constructor() {
        this.api = embodied.api;
    }
    init(done) {
        const jibo = Runtime_1.default.instance;
        embodied.api.init(jibo)
            .then(() => done())
            .catch(err => {
            log_1.default.error(`Error initializing EmbodiedDialog: `, err);
            done();
        });
    }
}
Runtime_1.default.registerPlugin(EmbodiedPlugin, 'embodied', {
    depends: ['anim-db', 'expression', 'emotion'],
    api: true,
    name: 'embodied'
});
exports.default = EmbodiedPlugin;

},{"../Runtime":1,"../log":75,"jibo-embodied-dialog":undefined}],81:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const emotion = require("jibo-emotion-system");
const Runtime_1 = require("../Runtime");
class EmotionPlugin {
    constructor() {
        this.api = emotion.api;
    }
    init(done) {
        const jibo = Runtime_1.default.instance;
        emotion.api.init({ jibo: jibo })
            .then(() => done())
            .catch(e => done(e));
    }
}
Runtime_1.default.registerPlugin(EmotionPlugin, 'emotion', {
    depends: ['action'],
    api: true,
    name: 'emotion'
});
exports.default = EmotionPlugin;

},{"../Runtime":1,"jibo-emotion-system":undefined}],82:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_expression_client_1 = require("jibo-expression-client");
const Runtime_1 = require("../Runtime");
class ExpressionPlugin {
    constructor() {
        this.api = jibo_expression_client_1.expression;
    }
    init(done) {
        const jibo = Runtime_1.default.instance;
        if (jibo.runMode === jibo.RunMode.UNIT_TESTS) {
            return done();
        }
        const record = Runtime_1.default.instance.records.find(record => (record.name === 'expression'));
        if (record) {
            this.api.init(record.port, jibo)
                .then(() => {
                this.api.events.dofs.on((data) => {
                    Runtime_1.default.instance.face.eye.display(data.timestamp, data.dofValues, data.metadata);
                });
                return this.api.setSkillRoot(process.cwd());
            })
                .then(() => done())
                .catch(error => done(error));
        }
        else {
            done(new Error(`Registry record missing for 'expression'`));
        }
    }
}
Runtime_1.default.registerPlugin(ExpressionPlugin, 'expression', {
    depends: ['service-records'],
    api: true,
    name: 'expression'
});
exports.default = ExpressionPlugin;

},{"../Runtime":1,"jibo-expression-client":undefined}],83:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const path = require("path");
const Runtime_1 = require("../Runtime");
const jibo_plugins_1 = require("jibo-plugins");
const log_1 = require("../log");
const log = log_1.default.createChild('Fonts');
class FontsPlugin {
    init(done) {
        if (Runtime_1.default.electron) {
            const src = path.join(jibo_plugins_1.PathUtils.findRoot(__dirname), 'resources/fonts.css');
            log.debug('Electron runtime. Loading fonts from', src);
            Runtime_1.default.instance.loader.load(src, (err, style) => {
                log.debug('CSS loaded. Loading fonts...', src);
                document.head.appendChild(style);
                Promise.all([
                    document.fonts.load('bold 1em "Proxima Nova Soft"'),
                    document.fonts.load('normal 1em "Proxima Nova Soft"'),
                    document.fonts.load('bold 1em "Proxima Nova"'),
                    document.fonts.load('normal 1em "Proxima Nova Light"')
                ]).then(() => {
                    log.info('Fonts loaded');
                    done();
                });
            });
        }
        else {
            log.debug('Non-Electron build; skipping font loading');
            done();
        }
    }
}
Runtime_1.default.registerPlugin(FontsPlugin, 'fonts', {
    depends: ['loader'],
    electron: true
});
exports.default = FontsPlugin;

},{"../Runtime":1,"../log":75,"jibo-plugins":undefined,"path":undefined}],84:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const im = require("jibo-interaction-memory");
const Runtime_1 = require("../Runtime");
class InteractionMemoryPlugin {
    constructor() {
        this.api = im.api;
    }
    init(done) {
        const jibo = Runtime_1.default.instance;
        if (jibo.runMode === jibo.RunMode.UNIT_TESTS) {
            return done();
        }
        try {
            im.api.init(jibo);
            done();
        }
        catch (error) {
            jibo.log.error("Could not initialize interaction memory plugin: ", error);
            done(error);
        }
    }
}
Runtime_1.default.registerPlugin(InteractionMemoryPlugin, 'im', {
    depends: ['services'],
    api: true,
    name: 'im'
});
exports.default = InteractionMemoryPlugin;

},{"../Runtime":1,"jibo-interaction-memory":undefined}],85:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jetstream_client_1 = require("@jibo/jetstream-client");
const Runtime_1 = require("../Runtime");
const log_1 = require("../log");
const log = log_1.default.createChild('Jetstream');
const DEBUG = true;
class JetstreamPlugin {
    constructor() {
        this.api = jetstream_client_1.api;
    }
    init(done) {
        const jibo = Runtime_1.default.instance;
        if (jibo.runMode === jibo.RunMode.UNIT_TESTS) {
            return done();
        }
        const record = Runtime_1.default.instance.records.find(record => (record.name === 'jetstream'));
        if (!record) {
            done(new Error(`Couldn't find 'jetstream' record`));
        }
        else {
            this.api.init({
                hostname: 'localhost',
                port: record.port
            })
                .then(() => done())
                .catch(error => done(error));
            if (DEBUG) {
                this.api.events.error.on((error) => {
                    log.error(`Jetstream: error received: `, error);
                });
                this.api.events.sos.on(() => {
                    log.info(`Jetstream: sos received`);
                });
                this.api.events.eos.on(() => {
                    log.info(`Jetstream: eos received`);
                });
                this.api.events.hjHeard.on(() => {
                    log.info(`Jetstream: hjHeard`);
                });
                this.api.events.localTurnStarted.on(() => {
                    log.info(`Jetstream: localTurnStarted`);
                });
                this.api.events.localTurnResult.on((data) => {
                    log.info(`Jetstream: localTurnResult: `, data);
                });
                this.api.events.globalTurnStarted.on(() => {
                    log.info(`Jetstream: globalTurnStarted`);
                });
                this.api.events.globalTurnResult.on((data) => {
                    log.info(`Jetstream: globalTurnResult: `, data);
                });
                this.api.events.skillSwitch.on((data) => {
                    log.info(`Jetstream: skillSwitch: `, data);
                });
            }
        }
    }
}
Runtime_1.default.registerPlugin(JetstreamPlugin, 'jetstream', {
    depends: ['service-records'],
    api: true,
    name: 'jetstream'
});
exports.default = JetstreamPlugin;

},{"../Runtime":1,"../log":75,"@jibo/jetstream-client":undefined}],86:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
const jibo_client_framework_1 = require("jibo-client-framework");
const Runtime_1 = require("../Runtime");
const log_1 = require("../log");
const log = log_1.default.createChild('Lifecycle');
class IPC extends events_1.EventEmitter {
    constructor() {
        super();
    }
    send(channel, ...args) {
        this.emit(`send-${channel}`, args);
    }
}
const ipc = Runtime_1.default.ipcRenderer || new IPC();
class Lifecycle extends events_1.EventEmitter {
    constructor() {
        super();
        this.onShutdown = this.onShutdown.bind(this);
        this.onMessage = this.onMessage.bind(this);
        ipc.on('shutdown', this.onShutdown);
    }
    init(done) {
        const jibo = Runtime_1.default.instance;
        if (jibo.runMode === jibo.RunMode.UNIT_TESTS) {
            return done();
        }
        const records = jibo.records;
        for (let i = 0; i < records.length; i++) {
            let record = records[i];
            if (record.name === 'skills-service') {
                this._skillServiceHost = `ws://127.0.0.1:${record.port}`;
                break;
            }
        }
        if (!this._skillServiceHost) {
            done('Skills Service is down');
        }
        this._client = new jibo_client_framework_1.WSClient(this._skillServiceHost);
        this._client.once('open', () => {
            this._client.send({
                command: 'initDone'
            });
        });
        this._client.on('message', this.onMessage);
        this.once('init', done);
    }
    finished() {
        this._client.send({
            command: 'finished'
        });
        ipc.send('finished');
    }
    onMessage(command) {
        log.debug('command', command, command.command === 'show');
        if (command.command === 'shutdown') {
            this.emit('shutdown');
            setTimeout(() => {
                ipc.send('finished');
            }, 100);
        }
        else if (command.command === 'show') {
            ipc.send('show');
            this.emit('init');
        }
    }
    onShutdown() {
        this._client.send({
            command: 'shutdown'
        });
    }
}
Runtime_1.default.registerPlugin(Lifecycle, 'lifecycle', {
    api: true,
    depends: ['service-records']
});
exports.default = Lifecycle;

},{"../Runtime":1,"../log":75,"events":undefined,"jibo-client-framework":undefined}],87:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../Runtime");
const HomeLocation_1 = require("../utils/location/HomeLocation");
class LocationPlugin {
    init(done) {
        HomeLocation_1.default.init();
        done();
    }
}
Runtime_1.default.registerPlugin(LocationPlugin, 'location', {
    depends: ['services'],
    api: false,
    name: 'location'
});
exports.default = LocationPlugin;

},{"../Runtime":1,"../utils/location/HomeLocation":207}],88:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../Runtime");
const Media_1 = require("../services/media/Media");
class MediaPlugin {
    constructor() {
        this.api = new Media_1.Media();
    }
    init(done) {
        const jibo = Runtime_1.default.instance;
        if (jibo.runMode === jibo.RunMode.UNIT_TESTS) {
            return done();
        }
        this.api.init(() => {
            done(null, this.api);
        });
    }
}
Runtime_1.default.registerPlugin(MediaPlugin, 'media', {
    depends: ['services'],
    api: true,
    name: 'media'
});
exports.default = MediaPlugin;

},{"../Runtime":1,"../services/media/Media":184}],89:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const url = require("url");
const Runtime_1 = require("../Runtime");
const jibo_client_framework_1 = require("jibo-client-framework");
const SerialTimer_1 = require("../utils/perf/SerialTimer");
const log_1 = require("../log");
const log = log_1.default.createChild('Registry');
class RegistryPlugin {
    init(done) {
        const jibo = Runtime_1.default.instance;
        if (jibo.runMode === jibo.RunMode.UNIT_TESTS) {
            log.debug('UNIT_TESTS run mode; skipping init');
            return done();
        }
        const timer = new SerialTimer_1.default('getRegistryHost', jibo.initTimer);
        if (!Runtime_1.default.electron) {
            timer.stop();
            log.debug('Not Electron build; skipping init');
            return done();
        }
        if (jibo.options.registryHost) {
            jibo.registryHost = jibo.options.registryHost;
            timer.stop();
            log.debug('Set Registry host to', jibo.registryHost);
            return done();
        }
        log.debug('Setting up ipcRenderer set-context event handler');
        Runtime_1.default.ipcRenderer.on('set-context', (sender, initData) => {
            if (typeof initData === 'string' || initData instanceof String) {
                jibo.registryHost = initData;
                log.debug('Set Registry host to', jibo.registryHost);
            }
            else {
                jibo.registryHost = initData.registryHost;
                log.debug('Set Registry host to', initData.registryHost);
                if (initData.token) {
                    log.debug('Set session token to', initData.token);
                    jibo.session.token = initData.token;
                }
                if (initData.context) {
                    jibo.electronContext = initData.context;
                    log.debug('Set Electron context');
                }
            }
            this._createRegistryClientInstance(jibo);
            timer.stop();
            done();
        });
    }
    _createRegistryClientInstance(jibo) {
        const hostUrl = url.parse(jibo.registryHost);
        jibo_client_framework_1.RegistryClient.createInstance(hostUrl.hostname, parseInt(hostUrl.port));
    }
}
Runtime_1.default.registerPlugin(RegistryPlugin, 'registry');
exports.default = RegistryPlugin;

},{"../Runtime":1,"../log":75,"../utils/perf/SerialTimer":212,"jibo-client-framework":undefined,"url":undefined}],90:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../Runtime");
class RenderingPlugin {
    constructor() {
        const jibo = Runtime_1.default.instance;
        jibo.loader
            .register(jibo.rendering.tasks.ColorAlphaTask, 40)
            .register(jibo.rendering.tasks.TimelineTask, 60)
            .register(jibo.rendering.tasks.ShapesTask, 70)
            .register(jibo.rendering.tasks.KeysTask, 80)
            .register(jibo.rendering.tasks.KeysDataTask, 81)
            .register(jibo.rendering.tasks.SpritesheetTask, 90)
            .register(jibo.rendering.tasks.TextureTask, 30)
            .register(jibo.rendering.tasks.CompressedImageTask, 25);
    }
    init(done) {
        done();
    }
}
Runtime_1.default.registerPlugin(RenderingPlugin, 'rendering', {
    depends: ['loader'],
    electron: true
});
exports.default = RenderingPlugin;

},{"../Runtime":1}],91:[function(require,module,exports){
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../Runtime");
const log_1 = require("../log");
const jibo_cai_utils_1 = require("jibo-cai-utils");
const log = log_1.default.createChild('ServiceRecords');
const MAX_TRIES = 5;
const WAIT_BETWEEN = 2000;
const TIMEOUT_INCR = 1000;
class ServiceRecordsPlugin {
    init(done) {
        const jibo = Runtime_1.default.instance;
        if (jibo.runMode === jibo.RunMode.UNIT_TESTS) {
            log.debug('Skipping loading registry services in unit tests');
            return done();
        }
        const asset = {
            src: jibo.registryHost,
            format: 'json',
            timeout: 3000
        };
        log.debug('Asset to load:', asset);
        let attempt = 0;
        let services = null;
        (() => __awaiter(this, void 0, void 0, function* () {
            while (services === null) {
                attempt++;
                try {
                    services = yield jibo_cai_utils_1.PromiseUtils.promisify(h => jibo.loader.load(asset, h));
                }
                catch (err) {
                    if (attempt === MAX_TRIES) {
                        log.error(`Error loading registry service at ${jibo.registryHost} on attempt #${attempt}; giving up`, err);
                        return done(new Error(`Error loading registry service at ${jibo.registryHost}: ${err.Message}`));
                    }
                    else {
                        log.warn(`Error loading registry service at ${jibo.registryHost} on attempt #${attempt}; will attempt a total of ${MAX_TRIES} times`, err);
                        asset.timeout += TIMEOUT_INCR;
                        yield new Promise(h => setTimeout(h, WAIT_BETWEEN));
                    }
                }
            }
            const systemManagerFirst = (a, b) => {
                if (a.name === "system-manager") {
                    return -1;
                }
                if (b.name === "system-manager") {
                    return 1;
                }
                return -1;
            };
            if (services !== null) {
                log.debug(`Loaded registry service at ${jibo.registryHost}`, services);
                const records = services.records ? services.records : services;
                jibo.records = records.sort(systemManagerFirst);
                done();
            }
        }))();
    }
}
Runtime_1.default.registerPlugin(ServiceRecordsPlugin, 'service-records', {
    depends: ['loader', 'registry']
});
exports.default = ServiceRecordsPlugin;

},{"../Runtime":1,"../log":75,"jibo-cai-utils":undefined}],92:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const async = require("async");
const ServiceClients = require("jibo-service-clients");
const Runtime_1 = require("../Runtime");
const SerialTimer_1 = require("../utils/perf/SerialTimer");
const ParallelTimer_1 = require("../utils/perf/ParallelTimer");
const log_1 = require("../log");
const log = log_1.default.createChild('Services');
class ServicesPlugin {
    constructor() {
        const jibo = Runtime_1.default.instance;
        this.serviceInit = {
            'global-manager': (service, callback) => {
                jibo.globalEvents.init(service, callback);
            },
            kb: (service, callback) => {
                jibo.kb.init(service, (err) => {
                    if (!err) {
                        jibo.kb.initLoop();
                        jibo.kb.initMedia();
                    }
                    callback(err);
                });
            },
            remote: (service, callback) => {
                jibo.remote.init(service, callback);
            }
        };
    }
    init(done) {
        const jibo = Runtime_1.default.instance;
        if (jibo.runMode === jibo.RunMode.UNIT_TESTS) {
            return done();
        }
        const tasks = [];
        const parallelTimer = new ParallelTimer_1.default('parallelInitializedServices', jibo.initTimer);
        jibo.records.forEach((service) => {
            const initFunction = this.serviceInit[service.name];
            if (initFunction) {
                tasks.push((_callback) => {
                    const timer = new SerialTimer_1.default(service.name, parallelTimer);
                    initFunction(service, (error, param) => {
                        timer.stop();
                        _callback();
                    });
                });
            }
        });
        tasks.push((callback) => {
            ServiceClients.init(Runtime_1.default.instance, jibo.records, callback, (initFunction, service) => {
                return (_callback) => {
                    const timer = new SerialTimer_1.default(service, parallelTimer);
                    initFunction((error, param) => {
                        timer.stop();
                        _callback();
                    });
                };
            });
        });
        async.parallel(tasks, (error, results) => {
            if (error) {
                log.debug('Error: ', error);
                done(error);
            }
            else {
                parallelTimer.stop();
                done();
            }
        });
    }
}
Runtime_1.default.registerPlugin(ServicesPlugin, 'services', {
    depends: ['service-records']
});
exports.default = ServicesPlugin;

},{"../Runtime":1,"../log":75,"../utils/perf/ParallelTimer":210,"../utils/perf/SerialTimer":212,"async":undefined,"jibo-service-clients":undefined}],93:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../Runtime");
const jibo_plugins_1 = require("jibo-plugins");
const semver = require("semver");
const log_1 = require("../log");
const log = log_1.default.createChild('Versions');
class VersionsPlugin {
    constructor() {
        const jibo = Runtime_1.default.instance;
        const dir = jibo_plugins_1.PathUtils.findRoot(__dirname);
        this._packageInfo = require(`${dir}/package.json`);
        this.jibo = this._packageInfo.version;
        jibo.version = this.jibo;
    }
    init(done) {
        const jibo = Runtime_1.default.instance;
        if (jibo.runMode === jibo.RunMode.UNIT_TESTS) {
            return done();
        }
        let tbd;
        try {
            tbd = require('/opt/jibo/Jibo/Skills/jibo-tbd/package.json');
        }
        catch (err) {
            if (jibo.runMode === jibo.RunMode.ON_ROBOT) {
                log.warn('no full-stack release number found', err);
            }
            tbd = { version: '8.67.5309' };
        }
        this.release = tbd.version;
        if (Runtime_1.default.electron) {
            for (let i = 0; i < jibo.records.length; i++) {
                const service = jibo.records[i];
                if (service.name === 'skills-service') {
                    this._getSSMVersion(service, done);
                    break;
                }
            }
        }
        else {
            done();
        }
    }
    supported(currentPlatformVersion) {
        const jiboVersion = this.requiresPlatform;
        this.platform = currentPlatformVersion;
        return semver.satisfies(currentPlatformVersion, jiboVersion);
    }
    get requiresPlatform() {
        return this._packageInfo.platform;
    }
    get packageInfo() {
        return this._packageInfo;
    }
    toJSON() {
        return {
            jibo: this.jibo,
            ssm: this.ssm,
            platform: this.platform,
            release: this.release
        };
    }
    _getSSMVersion(service, done) {
        const url = "http://" + service.host + ":" + service.port + '/version';
        const request = new XMLHttpRequest();
        request.open("GET", url, true);
        request.onload = () => {
            if (request.status === 200) {
                const response = JSON.parse(request.response);
                this.ssm = response.version;
            }
            else {
                log.warn('Unable to request SSM version');
            }
            done();
        };
        request.send();
    }
}
Runtime_1.default.registerPlugin(VersionsPlugin, 'versions', {
    depends: ['services'],
    api: true
});
exports.default = VersionsPlugin;

},{"../Runtime":1,"../log":75,"/opt/jibo/Jibo/Skills/jibo-tbd/package.json":undefined,"jibo-plugins":undefined,"semver":undefined}],94:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
const Runtime_1 = require("../Runtime");
const log_1 = require("../log");
const path = require("path");
const jibo_plugins_1 = require("jibo-plugins");
const log = log_1.default.createChild('VolumePlugin');
const END_OF_BOUNDS = 'SFX_EndofBounds';
const VOLUME_UPDOWN = 'SFX_VolumeIncDec';
const HW_MIN_VOLUME = 0.25;
const HW_MAX_VOLUME = 1;
const DEFAULT_VOLUME = 7;
class VolumePlugin extends events_1.EventEmitter {
    constructor() {
        super(...arguments);
        this.MAX_VOLUME = 10;
        this.MIN_VOLUME = 1;
        this.currentVolume = DEFAULT_VOLUME;
        this._lastVolume = DEFAULT_VOLUME;
        this._volumeChanging = false;
        this.onVoiceCommand = (command) => {
            if (command && command.entities.volumeLevel) {
                this.changeVolume(command.intent, command.entities.volumeLevel);
            }
            Runtime_1.default.instance.globalEvents.shared.nonInterruptingGlobal.emit();
        };
    }
    init(callback) {
        Runtime_1.default.instance.globalEvents.volume.on(this.onVoiceCommand);
        Promise.all([
            new Promise((resolve) => {
                if (Runtime_1.default.instance.runMode === Runtime_1.default.instance.RunMode.UNIT_TESTS) {
                    return resolve();
                }
                Runtime_1.default.instance.kb.createModel('/settings').loadRoot((err, root) => {
                    if (err || !root) {
                        log.error('KB error, no root found for settings', err);
                        resolve();
                    }
                    else {
                        this._root = root;
                        if (root.data.volume === undefined) {
                            this._setVolume(resolve, true);
                        }
                        else {
                            this.currentVolume = Math.max(Math.min(parseInt(root.data.volume), this.MAX_VOLUME), this.MIN_VOLUME);
                            this._setVolume(resolve, true);
                        }
                    }
                });
            }),
            new Promise((resolve) => {
                Runtime_1.default.instance.loader.load(path.join(jibo_plugins_1.PathUtils.findRoot(__dirname), 'resources/audio/SFX_EndofBounds.m4a'), () => {
                    resolve();
                });
            }),
            new Promise((resolve) => {
                Runtime_1.default.instance.loader.load(path.join(jibo_plugins_1.PathUtils.findRoot(__dirname), 'resources/audio/SFX_VolumeIncDec.m4a'), () => {
                    resolve();
                });
            })
        ]).then(() => {
            callback();
        }, (err) => {
            callback(err);
        });
    }
    changeVolume(intent, value) {
        if (this._volumeChanging) {
            log.warn('volume change already in progress. ignoring command: ', intent);
            return;
        }
        this._volumeChanging = true;
        switch (intent) {
            case 'volumeUp':
                this.currentVolume = Math.min(this.currentVolume + 2, this.MAX_VOLUME);
                break;
            case 'volumeDown':
                this.currentVolume = Math.max(this.currentVolume - 2, this.MIN_VOLUME);
                break;
            case 'volumeToValue':
                this.currentVolume = Math.max(Math.min(parseInt(value), this.MAX_VOLUME), this.MIN_VOLUME);
                break;
        }
        this._setVolume();
    }
    destroy() {
        Runtime_1.default.instance.globalEvents.volume.removeListener(this.onVoiceCommand);
        Runtime_1.default.instance.sound.remove(VOLUME_UPDOWN);
        Runtime_1.default.instance.sound.remove(END_OF_BOUNDS);
    }
    _setVolume(callback, silent) {
        let hwRange = HW_MAX_VOLUME - HW_MIN_VOLUME;
        let userRange = this.MAX_VOLUME - this.MIN_VOLUME;
        let normalizedVolume = (this.currentVolume - this.MIN_VOLUME) / userRange;
        let hwVolume = HW_MIN_VOLUME + (normalizedVolume * hwRange);
        Runtime_1.default.instance.system.setMasterVolume(hwVolume, (err) => {
            if (err) {
                if (Runtime_1.default.instance.runMode !== Runtime_1.default.instance.RunMode.ON_ROBOT) {
                    log.warn(`tried setting volume, but this isn't a robot`);
                }
                else {
                    log.error('error setting volume: ', err);
                }
            }
            if (!silent) {
                if (this._lastVolume === this.currentVolume) {
                    if (this._lastVolume === this.MAX_VOLUME || this._lastVolume === this.MIN_VOLUME) {
                        Runtime_1.default.instance.sound.play(END_OF_BOUNDS);
                    }
                }
                else {
                    Runtime_1.default.instance.sound.play(VOLUME_UPDOWN);
                }
            }
            this._lastVolume = this.currentVolume;
            this.emit('change', this.currentVolume);
            if (Runtime_1.default.instance.runMode === Runtime_1.default.instance.RunMode.UNIT_TESTS) {
                this._volumeChanging = false;
                if (callback) {
                    return callback();
                }
                return;
            }
            this._root.data.volume = this.currentVolume;
            this._root.save((err) => {
                if (err) {
                    log.warn('error saving volume to KB', err);
                }
                this._volumeChanging = false;
                this.emit('change', this.currentVolume);
                if (callback) {
                    callback();
                }
            });
        });
    }
}
Runtime_1.default.registerPlugin(VolumePlugin, 'volume', {
    depends: ['services', 'loader'],
    api: true,
    name: 'volume'
});
exports.default = VolumePlugin;

},{"../Runtime":1,"../log":75,"events":undefined,"jibo-plugins":undefined,"path":undefined}],95:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const context = require("./api");
const Runtime_1 = require("../../Runtime");
class ContextPlugin {
    constructor() {
        this.api = context;
    }
    init(done) {
        this.api.init()
            .then(() => done())
            .catch(e => done(e));
    }
}
Runtime_1.default.registerPlugin(ContextPlugin, 'context', {
    depends: ['registry', 'emotion', 'location', 'action'],
    api: true,
    name: 'context'
});
exports.default = ContextPlugin;

},{"../../Runtime":1,"./api":97}],96:[function(require,module,exports){
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_cai_utils_1 = require("jibo-cai-utils");
const context = require("./api");
const Runtime_1 = require("../../Runtime");
const log_1 = require("../../log");
const log = log_1.default.createChild('Context');
const prify = jibo_cai_utils_1.PromiseUtils.promisify;
const timeout = jibo_cai_utils_1.PromiseUtils.timeout;
class ContextProvider {
    init() {
        return __awaiter(this, void 0, void 0, function* () {
            try {
                const rootNode = yield Runtime_1.default.instance.kb.loop.loadRoot();
                this.ownerNode = (yield Runtime_1.default.instance.kb.loop.load(rootNode.getEdges('owner')[0]));
            }
            catch (err) {
                log.warn('Unable to load owner information from KB', err);
            }
            try {
                const identity = yield prify(h => Runtime_1.default.instance.systemManager.getIdentity(h));
                const isBlack = identity.serial_number ? identity.serial_number.toUpperCase()[3] === 'B' : false;
                this.jiboColor = isBlack ? context.JiboColor.BLACK : context.JiboColor.WHITE;
            }
            catch (err) {
                log.warn('Unable to determine Jibo color information', err);
            }
            this.resetSkillContext();
        });
    }
    updateSkillContext(skill) {
        this.skill = skill;
    }
    resetSkillContext() {
        this.skill = {
            id: null
        };
    }
    getContext(speakers, omitLoop = false) {
        return __awaiter(this, void 0, void 0, function* () {
            let runtime = {
                character: null,
                perception: null,
                location: null,
                loop: null,
                dialog: null
            };
            try {
                runtime = yield this.getRuntimeContext(speakers, omitLoop);
            }
            catch (error) {
                log.error('Unable to retreive RuntimeContext -- will only send SkillContext:', error);
            }
            return {
                runtime,
                skill: this.skill
            };
        });
    }
    getRuntimeContext(speakers, omitLoop = false) {
        return __awaiter(this, void 0, void 0, function* () {
            let emotionName = null;
            let emotionValues = null;
            try {
                emotionName = Runtime_1.default.instance.emotion.getNearestEmotion().name;
                emotionValues = Runtime_1.default.instance.emotion.getCurrentEmotionalValues();
            }
            catch (err) {
                log.warn('Unable to retrieve Jibo\'s emotions', err);
            }
            const emotion = {
                name: emotionName,
                valence: emotionValues && emotionValues.valence,
                confidence: emotionValues && emotionValues.confidence
            };
            let social = null;
            let playful = null;
            try {
                social = Runtime_1.default.instance.action.getMotivationalDriveValue(Runtime_1.default.instance.action.types.DriveName.SOCIAL);
                playful = Runtime_1.default.instance.action.getMotivationalDriveValue(Runtime_1.default.instance.action.types.DriveName.PLAYFUL);
            }
            catch (err) {
                log.warn('Unable to retrieve Jibo\'s motiviations', err);
            }
            const motivation = {
                social,
                playful
            };
            const character = {
                emotion,
                motivation
            };
            let location = null;
            const jiboHome = Runtime_1.default.instance.utils.Location.jiboHome;
            if (jiboHome) {
                location = {
                    city: jiboHome.city,
                    state: jiboHome.state,
                    stateAbbr: jiboHome.stateAbbr,
                    country: jiboHome.country,
                    countryCode: jiboHome.countryCode,
                    lat: jiboHome.lat,
                    lng: jiboHome.lng,
                    iso: (new Runtime_1.default.instance.utils.DateTime(null, null, jiboHome.timezone)).toISOString()
                };
            }
            let loop = null;
            try {
                loop = yield this.getLoopContext(omitLoop);
            }
            catch (err) {
                log.warn('Unable to retrieve Jibo\'s loop information', err);
            }
            let speaker;
            if (speakers) {
                speaker = (speakers.accepted && speakers.accepted.length) ? speakers.accepted[0].id : null;
            }
            else {
                const speakerCandidate = Runtime_1.default.instance.lps.identity.getActiveSpeaker();
                speaker = (speakerCandidate && speakerCandidate.idInfo.id);
            }
            const peoplePresent = Runtime_1.default.instance.lps.identity.getPresentPersons();
            const perception = {
                speaker,
                peoplePresent
            };
            const dialog = {
                referent: null
            };
            return {
                character,
                perception,
                location,
                loop,
                dialog
            };
        });
    }
    getLoopContext(omitLoop) {
        return __awaiter(this, void 0, void 0, function* () {
            let users = null;
            let jibo = null;
            const owner = (this.ownerNode && this.ownerNode.id);
            const loopId = (this.ownerNode && this.ownerNode.data && this.ownerNode.data.loopId);
            if (!omitLoop) {
                let loopNodes = null;
                try {
                    const loopPr = Runtime_1.default.instance.kb.loop.loadLoop()
                        .then((nodes) => {
                        this.cachedLoopNodes = nodes;
                        return this.cachedLoopNodes;
                    });
                    loopNodes = yield timeout(loopPr, 1500, `Timed-out loading Jibo's loop -- 'jibo' and 'users' will be empty.`);
                }
                catch (err) {
                    log.warn(`Unable to load Jibo's loop, defaulting to cached loop nodes.`, err);
                    loopNodes = this.cachedLoopNodes;
                }
                if (loopNodes) {
                    users = [];
                    loopNodes.forEach(loopNode => {
                        if (loopNode.isJibo) {
                            jibo = {
                                color: this.jiboColor,
                                birthdate: loopNode.created,
                                id: loopNode.id
                            };
                        }
                        else {
                            let user = {
                                firstName: loopNode.firstName,
                                lastName: loopNode.lastName,
                                phoneticName: loopNode.toString(),
                                gender: loopNode.gender,
                                birthdate: loopNode.data.birthday,
                                id: loopNode.id,
                                accountId: loopNode.data.accountId,
                            };
                            users.push(user);
                        }
                    });
                }
            }
            return {
                loopId,
                users,
                jibo,
                owner
            };
        });
    }
}
exports.ContextProvider = ContextProvider;

},{"../../Runtime":1,"../../log":75,"./api":97,"jibo-cai-utils":undefined}],97:[function(require,module,exports){
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const cloud = require("@jibo/interfaces");
const ContextProvider_1 = require("./ContextProvider");
exports.JiboColor = cloud.jibo.runtime.JiboColor;
const instance = new ContextProvider_1.ContextProvider();
function init() {
    return __awaiter(this, void 0, void 0, function* () {
        return instance.init();
    });
}
exports.init = init;
function getContext(speakers, omitLoop = false) {
    return __awaiter(this, void 0, void 0, function* () {
        return instance.getContext(speakers, omitLoop);
    });
}
exports.getContext = getContext;
function updateSkillContext(data) {
    instance.updateSkillContext(data);
}
exports.updateSkillContext = updateSkillContext;
function resetSkillContext() {
    instance.resetSkillContext();
}
exports.resetSkillContext = resetSkillContext;

},{"./ContextProvider":96,"@jibo/interfaces":undefined}],98:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const FontsPlugin_1 = require("./FontsPlugin");
const RegistryPlugin_1 = require("./RegistryPlugin");
const ServiceRecordsPlugin_1 = require("./ServiceRecordsPlugin");
const ServicesPlugin_1 = require("./ServicesPlugin");
const RenderingPlugin_1 = require("./RenderingPlugin");
const Lifecycle_1 = require("./Lifecycle");
const LocationPlugin_1 = require("./LocationPlugin");
const VersionsPlugin_1 = require("./VersionsPlugin");
const VolumePlugin_1 = require("./VolumePlugin");
const ExpressionPlugin_1 = require("./ExpressionPlugin");
const AnimDBPlugin_1 = require("./AnimDBPlugin");
const ActionPlugin_1 = require("./ActionPlugin");
const EmotionPlugin_1 = require("./EmotionPlugin");
const MediaPlugin_1 = require("./MediaPlugin");
const EmbodiedPlugin_1 = require("./EmbodiedPlugin");
const ContextPlugin_1 = require("./context/ContextPlugin");
const DevShellPlugin_1 = require("./DevShellPlugin");
const AutobotPlugin_1 = require("./AutobotPlugin");
const JetstreamPlugin_1 = require("./JetstreamPlugin");
const InteractionMemoryPlugin_1 = require("./InteractionMemoryPlugin");
exports.default = {
    FontsPlugin: FontsPlugin_1.default,
    RenderingPlugin: RenderingPlugin_1.default,
    RegistryPlugin: RegistryPlugin_1.default,
    ServiceRecordsPlugin: ServiceRecordsPlugin_1.default,
    ServicesPlugin: ServicesPlugin_1.default,
    Lifecycle: Lifecycle_1.default,
    LocationPlugin: LocationPlugin_1.default,
    VersionsPlugin: VersionsPlugin_1.default,
    VolumePlugin: VolumePlugin_1.default,
    ExpressionPlugin: ExpressionPlugin_1.default,
    AnimDBPlugin: AnimDBPlugin_1.default,
    ActionPlugin: ActionPlugin_1.default,
    EmotionPlugin: EmotionPlugin_1.default,
    MediaPlugin: MediaPlugin_1.default,
    EmbodiedPlugin: EmbodiedPlugin_1.default,
    ContextPlugin: ContextPlugin_1.default,
    DevShellPlugin: DevShellPlugin_1.default,
    AutobotPlugin: AutobotPlugin_1.default,
    JetstreamPlugin: JetstreamPlugin_1.default,
    InteractionMemoryPlugin: InteractionMemoryPlugin_1.default,
};

},{"./ActionPlugin":76,"./AnimDBPlugin":77,"./AutobotPlugin":78,"./DevShellPlugin":79,"./EmbodiedPlugin":80,"./EmotionPlugin":81,"./ExpressionPlugin":82,"./FontsPlugin":83,"./InteractionMemoryPlugin":84,"./JetstreamPlugin":85,"./Lifecycle":86,"./LocationPlugin":87,"./MediaPlugin":88,"./RegistryPlugin":89,"./RenderingPlugin":90,"./ServiceRecordsPlugin":91,"./ServicesPlugin":92,"./VersionsPlugin":93,"./VolumePlugin":94,"./context/ContextPlugin":95}],99:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const ViewManager_1 = require("./gui/ViewManager");
const TweenManager_1 = require("./tween/TweenManager");
const EyeContainer_1 = require("./eye/EyeContainer");
const GestureManager_1 = require("./input/GestureManager");
const Runtime_1 = require("../Runtime");
const log_1 = require("./log");
const log = log_1.default.createChild('FaceRenderer');
class FaceRenderer extends PIXI.WebGLRenderer {
    constructor(timer) {
        super(FaceRenderer.WIDTH, FaceRenderer.HEIGHT, {
            view: FaceRenderer.createView(),
            antialias: true
        });
        let texturesOnGPU = new Map();
        const origUpdate = this.textureManager.updateTexture;
        this.textureManager.updateTexture = function (texture, location) {
            if (!texture._destroyed && texture.hasLoaded && !texture._glTextures[this.renderer.CONTEXT_UID]) {
                let id = texture.imageUrl || texture.textureCacheIds[0];
                if (!id) {
                    if (texture === PIXI.Texture.WHITE.baseTexture) {
                        id = '<PIXI.Texture.WHITE>';
                    }
                    else {
                        id = '<no id>';
                    }
                }
                texturesOnGPU.set(texture, id);
                log.debug(`PIXI.TextureManager - uploaded BaseTexture with imageUrl or id of ${id} - # of textures on GPU: ${texturesOnGPU.size}`);
            }
            return origUpdate.call(this, texture, location);
        };
        const origDestroy = this.textureManager.destroyTexture;
        this.textureManager.destroyTexture = function (texture, skipRemove) {
            texture = texture.baseTexture || texture;
            if (texturesOnGPU.has(texture)) {
                const id = texturesOnGPU.get(texture);
                texturesOnGPU.delete(texture);
                log.debug(`PIXI.TextureManager - disposed BaseTexture with imageUrl or id of ${id} - # of textures on GPU: ${texturesOnGPU.size}`);
            }
            return origDestroy.call(this, texture, skipRemove);
        };
        this._webContextLost = (ev) => {
            log.error(`WebGL Context Lost because ${ev.statusMessage} - Previously ${texturesOnGPU.size} textures on GPU`);
            ev.preventDefault();
            this._paused = true;
            this._views.disabled = true;
            texturesOnGPU = new Map();
            this._views.reset();
            this._views.destroyBorder();
            if (this._eye.parent) {
                this._eye.parent.removeChild(this._eye);
            }
            this._eye.destroy();
            this.tween.stop();
            Runtime_1.default.instance.loader.deleteCache(ViewManager_1.default.GLOBAL_CACHE);
            Runtime_1.default.instance.loader.deleteCache(this.eye.CACHE_ID);
            Runtime_1.default.instance.lifecycle.finished();
        };
        this.view.addEventListener('webglcontextlost', this._webContextLost, false);
        this._webContextRestored = (ev) => {
            log.info(`WebGL Context restored!`);
            this._eye = new EyeContainer_1.default();
            this.init(this.view.parentNode, false);
            this._paused = false;
            this._views.disabled = false;
            Runtime_1.default.instance.lifecycle.finished();
        };
        this.view.addEventListener('webglcontextrestored', this._webContextRestored, false);
        window.listGpuTextures = () => {
            return Array.from(texturesOnGPU.values());
        };
        const loseContextExt = this.gl.getExtension('WEBGL_lose_context');
        window.loseWebGLContext = () => {
            loseContextExt.loseContext();
            setTimeout(() => {
                loseContextExt.restoreContext();
            }, 1000);
        };
        this.gl.getExtension('WEBGL_compressed_texture_s3tc');
        this.stage = new PIXI.Container();
        this.update = this.update.bind(this);
        this._paused = true;
        this._timer = timer;
        this._eye = new EyeContainer_1.default();
        this._views = new ViewManager_1.default(this);
        this._gestures = GestureManager_1.default.init(this);
        this.stage.addChild(this._views.stage);
        this._timer.on('update', this.update);
        this.plugins.prepare.limiter = new PIXI.prepare.TimeLimiter(10);
    }
    static createView() {
        const view = document.createElement('canvas');
        view.style.width = '100%';
        view.style.height = '100%';
        return view;
    }
    init(element, prepWorkers = true) {
        element.appendChild(this.view);
        this._views.init(null, prepWorkers);
        this._eye.init();
        this.paused = false;
    }
    get views() {
        return this._views;
    }
    get gestures() {
        return this._gestures;
    }
    get tween() {
        return TweenManager_1.default;
    }
    get eye() {
        return this._eye;
    }
    update(elapsed) {
        if (this._paused) {
            return;
        }
        TweenManager_1.default.update(elapsed);
        this._views.update(elapsed);
        try {
            this.render(this.stage);
        }
        catch (e) {
            log.warn(`Error while rendering. Resetting views and eye and returning to idle.`, e);
            this._views.reset();
            if (this._eye.parent) {
                this._eye.parent.removeChild(this._eye);
            }
            this._eye.destroy();
            this._eye = new EyeContainer_1.default();
            this.eye.init();
            Runtime_1.default.instance.lifecycle.finished();
        }
    }
    set paused(value) {
        if (value !== this._paused) {
            this._paused = value;
        }
    }
    get paused() {
        return this._paused;
    }
    reset() {
        this._eye.reset();
        this._views.reset();
        return super.reset();
    }
    destroy() {
        this.view.removeEventListener('webglcontextlost', this._webContextLost, false);
        this.view.removeEventListener('webglcontextrestored', this._webContextRestored, false);
        if (this._views) {
            this.stage.removeChild(this._views.stage);
            this._views.destroy();
            this._views = null;
        }
        if (this._timer) {
            this._timer.removeListener('update', this.update);
            this._timer = null;
        }
        this._paused = true;
        this.stage.destroy(true);
        this.stage = null;
        super.destroy(true);
    }
}
FaceRenderer.WIDTH = 1280;
FaceRenderer.HEIGHT = 720;
exports.default = FaceRenderer;

},{"../Runtime":1,"./eye/EyeContainer":113,"./gui/ViewManager":127,"./input/GestureManager":160,"./log":162,"./tween/TweenManager":174}],100:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
const jibo_keyframes_1 = require("jibo-keyframes");
const animate = require("pixi-animate");
const jibo_expression_client_1 = require("jibo-expression-client");
const path = require("path");
const Runtime_1 = require("../../Runtime");
const log_1 = require("./log");
class Layer {
    constructor(index, name) {
        this.index = index;
        this.name = name;
    }
    destroy() {
        this.index = null;
        this.name = null;
    }
}
Layer.EYE = 'Eye';
exports.Layer = Layer;
class EyeLayer extends Layer {
    constructor(index) {
        super(index, Layer.EYE);
    }
}
exports.EyeLayer = EyeLayer;
class TimelineLayer extends Layer {
    constructor(index, name, timeline, startTime, attach, offsetValue) {
        super(index, name);
        this.startTime = startTime;
        this.attach = attach;
        const instance = this.instance = new timeline.library.stage();
        let framerate = timeline.library.framerate;
        if (framerate !== KeysAnimation.FRAMERATE) {
            log_1.default.debug(`Timeline was animated at ${framerate} expecting ${KeysAnimation.FRAMERATE}, converting...`);
        }
        instance.framerate = KeysAnimation.FRAMERATE;
        if (/^\d+$/.test(offsetValue)) {
            this.offset = parseInt(offsetValue);
        }
        else if (instance.labelsMap && instance.labelsMap[offsetValue]) {
            this.offset = instance.labelsMap[offsetValue];
        }
        else {
            this.offset = 0;
        }
        instance.gotoAndStop(this.offset);
        if (attach) {
            instance.pivot.x = timeline.library.width / 2;
            instance.pivot.y = timeline.library.height / 2;
        }
        else {
            instance.pivot.x = 0;
            instance.pivot.y = 0;
        }
    }
    update(time, dofValues) {
        const instance = this.instance;
        const currFrame = Math.round((time - this.startTime) * instance.framerate);
        instance.gotoAndStop(this.offset + currFrame);
        if (this.attach) {
            instance.x = jibo_keyframes_1.conversion.toPixelsX(dofValues.eyeSubRootBn_t) + instance.pivot.x;
            instance.y = -jibo_keyframes_1.conversion.toPixelsX(dofValues.eyeSubRootBn_t_2) + instance.pivot.y;
            instance.rotation = -dofValues.eyeSubRootBn_r;
        }
    }
    destroy() {
        super.destroy();
        this.instance.destroy({ children: true });
        this.instance = null;
    }
}
exports.TimelineLayer = TimelineLayer;
class KeysAnimation extends events_1.EventEmitter {
    constructor(keysData) {
        super();
        this._keysData = keysData;
        this.id = keysData.id;
        this.name = path.basename(this.id);
        this.assetPack = keysData.assetPack;
        this.root = keysData.root;
        this.layers = [];
        this.onPlayTimeline = this.onPlayTimeline.bind(this);
        this.onPlayAudio = this.onPlayAudio.bind(this);
        this.onEvent = this.onEvent.bind(this);
        if (keysData.data) {
            this.data = keysData.data;
        }
        this.reorder();
    }
    get timelines() {
        return this._keysData.timelines;
    }
    get textures() {
        return this._keysData.textures;
    }
    get sounds() {
        return this._keysData.sounds;
    }
    set options(options) {
        if (this._options) {
            throw new Error("AnimationOptions can only be set once on a KeysAnimation.  Call getCleanCopy() to start fresh.");
        }
        this._options = options;
    }
    get options() {
        return this._options;
    }
    set instance(instance) {
        if (this._instance) {
            throw new Error("Instance can only be set once on a KeysAnimation.");
        }
        this._instance = instance;
        if (instance) {
            instance.events.general.on(this.onEvent);
            instance.events.audio.on(this.onPlayAudio);
            instance.events.pixi.on(this.onPlayTimeline);
        }
    }
    get instance() {
        return this._instance;
    }
    update(time, dofValues) {
        this._currentTime = time;
        for (let i = 0, len = this.layers.length; i < len; i++) {
            const layer = this.layers[i];
            if (layer instanceof TimelineLayer) {
                layer.update(time, dofValues);
            }
        }
        this.emit(KeysAnimation.UPDATE, time, dofValues);
    }
    set data(data) {
        this.layers.length = 0;
        for (let i = 0; i < data.layers.length; i++) {
            if (data.layers[i].type === Layer.EYE) {
                this.layers.push(new EyeLayer(i));
                break;
            }
        }
        this._data = data;
    }
    get data() {
        return this._data;
    }
    playSync(instance, event, callback) {
        if (typeof event === "function") {
            callback = event;
            event = null;
        }
        const startFrame = event ? instance.labelsMap[event] : 0;
        let endFrame = instance.totalFrames - 1;
        if (event) {
            endFrame = instance.labelsMap[event + '_stop'] ||
                instance.labelsMap[event + '_loop'];
        }
        let timelineDone = false;
        let keysDone = false;
        instance.gotoAndStop(startFrame);
        const onComplete = () => {
            if (keysDone && timelineDone) {
                this.removeListener(KeysAnimation.UPDATE, onUpdate);
                this.removeListener(KeysAnimation.STOPPED, onStopped);
                if (callback) {
                    callback();
                }
            }
        };
        const onTimelineDone = () => {
            timelineDone = true;
            onComplete();
        };
        const onUpdate = (time) => {
            const currentFrame = Math.round(time * instance.framerate);
            const frame = startFrame + currentFrame;
            if (frame <= endFrame) {
                instance.gotoAndStop(frame);
                if (frame === endFrame) {
                    onTimelineDone();
                }
            }
        };
        const onStopped = () => {
            keysDone = true;
            if (!timelineDone) {
                animate.Animator.to(instance, endFrame, onTimelineDone);
            }
            else {
                onComplete();
            }
        };
        this.on(KeysAnimation.STOPPED, onStopped);
        this.on(KeysAnimation.UPDATE, onUpdate);
    }
    destroyWhenComplete() {
        const state = this._instance ? this._instance.state : jibo_expression_client_1.AnimationState.INVALID;
        switch (state) {
            case jibo_expression_client_1.AnimationState.INVALID:
            case jibo_expression_client_1.AnimationState.CANCELLED:
            case jibo_expression_client_1.AnimationState.STOPPED:
            case jibo_expression_client_1.AnimationState.REJECTED:
                this.destroy();
                break;
            default:
                const destroyCB = () => {
                    this.destroy();
                };
                this._instance.events.cancelled.once(destroyCB);
                this._instance.events.stopped.once(destroyCB);
                this._instance.events.rejected.once(destroyCB);
        }
    }
    destroy() {
        this.layers.forEach((layer) => {
            layer.destroy();
        });
        this.removeAllListeners();
        if (this.instance) {
            this.instance.destroy();
            this._instance = null;
        }
        Runtime_1.default.instance.loader.unload(this._loadToken);
        this._options = null;
        this.layers = null;
    }
    onEvent() {
    }
    onPlayAudio(payload) {
        this.sounds[payload.file].play();
    }
    reorder() {
        this.layers = this.layers.sort((a, b) => {
            return a.index - b.index;
        });
        this.emit(KeysAnimation.REORDER);
    }
    onPlayTimeline(payload) {
        const timeline = this.timelines[payload.file];
        if (!timeline) {
            throw new Error(`No timeline matching ${payload.file}`);
        }
        const layer = new TimelineLayer(payload.layerNum, payload.file, timeline, this._currentTime || 0, !!payload.attach, payload.offset);
        this.replaceOrAddTimelineLayer(layer);
        this.reorder();
    }
    replaceOrAddTimelineLayer(layer) {
        let i;
        for (i = 0; i < this.layers.length; i++) {
            if (this.layers[i].index === layer.index) {
                this.layers[i].destroy();
                break;
            }
        }
        this.layers[i] = layer;
    }
}
KeysAnimation.FRAMERATE = 30;
KeysAnimation.STARTED = 'STARTED';
KeysAnimation.STOPPED = 'STOPPED';
KeysAnimation.EVENT = 'EVENT';
KeysAnimation.CANCELLED = 'CANCELLED';
KeysAnimation.PLAY_AUDIO = 'play-audio';
KeysAnimation.PLAY_TIMELINE = 'play-pixi';
KeysAnimation.REORDER = 'reorder';
KeysAnimation.UPDATE = 'update';
exports.default = KeysAnimation;

},{"../../Runtime":1,"./log":107,"events":undefined,"jibo-expression-client":undefined,"jibo-keyframes":undefined,"path":undefined,"pixi-animate":undefined}],101:[function(require,module,exports){
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../../Runtime");
const KeysAnimation_1 = require("./KeysAnimation");
const jibo_cai_utils_1 = require("jibo-cai-utils");
const path = require("path");
const jiboKeyframes = require('jibo-keyframes');
class KeysData {
    constructor(id, src, cache) {
        this.dotAnimSrc = null;
        this.id = id || path.basename(src);
        this.src = src;
        this.cache = cache;
        this.timelines = {};
        this.sounds = {};
        this.textures = {};
    }
    addSound(id, sound) {
        this.sounds[id] = sound;
    }
    addTimeline(id, timeline) {
        this.timelines[id] = timeline;
    }
    addTexture(id, texture) {
        this.textures[id] = texture;
    }
    getAnim(options) {
        return __awaiter(this, void 0, void 0, function* () {
            const anim = new KeysAnimation_1.default(this);
            yield jibo_cai_utils_1.PromiseUtils.promisify(cb => {
                const load = Runtime_1.default.instance.loader.load({
                    id: this.id,
                    src: this.src,
                    cache: Runtime_1.default.instance.face.eye.CACHE_ID
                }, cb);
                anim._loadToken = load.tokens[0];
            });
            if (!options) {
                options = {};
            }
            anim.options = this.createAnimOptions(options);
            anim.instance = yield Runtime_1.default.instance.expression.createAnimation(anim.options);
            return anim;
        });
    }
    getAndPlayAnim(options, requestor) {
        return __awaiter(this, void 0, void 0, function* () {
            const anim = new KeysAnimation_1.default(this);
            yield jibo_cai_utils_1.PromiseUtils.promisify(cb => {
                const load = Runtime_1.default.instance.loader.load({
                    id: this.id,
                    src: this.src,
                    cache: Runtime_1.default.instance.face.eye.CACHE_ID
                }, cb);
                anim._loadToken = load.tokens[0];
            });
            if (!options) {
                options = {};
            }
            anim.options = this.createAnimOptions(options);
            anim.instance = yield Runtime_1.default.instance.expression.createAndPlayAnimation(anim.options, requestor);
            return anim;
        });
    }
    destroy() {
        this.timelines = null;
        this.textures = null;
        this.sounds = null;
    }
    createAnimOptions(options) {
        let data = null, src = null;
        if (!this.data) {
            src = this.dotAnimSrc;
            if (!src) {
                console.warn(`Generating missing anim data for ${this.src}.`);
            }
        }
        if (!src) {
            console.time('computeAnimObject');
            data = jiboKeyframes.computeAnimObject(this.data, this.src);
            console.timeEnd('computeAnimObject');
        }
        options = Object.assign({}, options, {
            path: this.root,
            src,
            data,
            cacheName: this.cache
        });
        return options;
    }
}
exports.default = KeysData;

},{"../../Runtime":1,"./KeysAnimation":100,"jibo-cai-utils":undefined,"jibo-keyframes":undefined,"path":undefined}],102:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../../Runtime");
const path = require("path");
const async = require("async");
const jibo_keyframes_1 = require("jibo-keyframes");
class Keyframes {
}
exports.Keyframes = Keyframes;
class KeyframesLayer {
}
exports.KeyframesLayer = KeyframesLayer;
class KeysLoader {
    constructor(src, root, assetId, skipAssetPack = false) {
        this.src = src;
        this.root = root;
        if (!skipAssetPack) {
            this.assetPack = Runtime_1.default.instance.utils.PathUtils.getAssetPack(assetId || '');
        }
    }
    load(callback) {
        const promise = new Promise((resolve, reject) => {
            this.innerNestedLoad(this.src, this.assetPack, (err, keyframes) => {
                if (err) {
                    return reject(err);
                }
                this.removeHoldSafesInReferences(keyframes);
                resolve(keyframes);
            }, undefined);
        });
        if (callback) {
            promise.then((keyframes) => {
                callback(null, keyframes);
            })
                .catch(callback);
        }
        else {
            return promise;
        }
    }
    innerNestedLoad(url, assetPack, complete, parentId) {
        Runtime_1.default.instance.loader.load(url, (err, keyframes) => {
            if (err) {
                return complete(err);
            }
            jibo_keyframes_1.JiboKeyframeInfo.onLoad(keyframes);
            if (parentId !== undefined) {
                this.fixLayerIds(keyframes, parentId);
            }
            const dir = path.dirname(url);
            this.resolveAssetRefs(keyframes, assetPack);
            let fileRefs;
            try {
                fileRefs = this.getKeyFileReferences(keyframes, dir);
            }
            catch (err) {
                return complete(err);
            }
            async.each(fileRefs, (ref, callback) => {
                this.innerNestedLoad(ref.url, ref.assetPack, (err, newkeyframes) => {
                    if (err) {
                        return callback(err);
                    }
                    ref.frames = newkeyframes;
                    const validUpto = ref.holdFinalPose ? ref.nextRefStart : ref.timeOffset + ref.frames.duration;
                    this.timeshift(ref.frames, ref.timeOffset, validUpto, ref.containerDuration - 1);
                    callback();
                }, ref.parentId);
            }, (err) => {
                if (err) {
                    return complete(err);
                }
                for (let ref of fileRefs) {
                    this.composite(ref.layerNumber, keyframes, ref.frames);
                }
                this.removeReferenceLayers(keyframes);
                complete(null, keyframes);
            });
        });
    }
    resolveAssetRefs(frames, assetPack) {
        if (assetPack) {
            for (let layer of frames.layers) {
                if (layer.type === 'Pixi') {
                    for (let keyframe of layer.keyframes) {
                        keyframe.value.Pixi = this.convertToAssetReference(assetPack, keyframe.value.Pixi);
                    }
                }
                else if (layer.type === 'Audio Event') {
                    for (let keyframe of layer.keyframes) {
                        keyframe.value.AudioEvent.file = this.convertToAssetReference(assetPack, keyframe.value.AudioEvent.file);
                    }
                }
                else if (layer.type.indexOf('Texture') !== -1) {
                    for (let keyframe of layer.keyframes) {
                        keyframe.value.Texture = this.convertToAssetReference(assetPack, keyframe.value.Texture);
                    }
                }
            }
        }
    }
    convertToAssetReference(assetPack, filepath) {
        const ASSETPACK_DELIMITER = '://';
        if (filepath && filepath.indexOf(ASSETPACK_DELIMITER) !== -1) {
            return filepath;
        }
        return assetPack + ASSETPACK_DELIMITER + filepath;
    }
    getKeyFileReferences(frames, refBase) {
        const fileRefs = [];
        for (let i = 0; i < frames.layers.length; i++) {
            const layer = frames.layers[i];
            if (layer.type === 'Reference' && layer.visible) {
                for (let keyi = 0; keyi < layer.keyframes.length; keyi++) {
                    const keyframe = layer.keyframes[keyi];
                    const atEnd = layer.keyframes.length === keyi + 1;
                    const nextRefStart = atEnd ? Infinity : layer.keyframes[keyi + 1].time;
                    let { url, assetPack } = this.getReferencedUrl(keyframe, refBase);
                    keyframe.childPrefix = `${layer.id}-${this.zeroPad(keyi, 2)}`;
                    fileRefs.push({
                        url,
                        assetPack,
                        parentId: keyframe.childPrefix,
                        holdFinalPose: keyframe.value.HoldFinalPose,
                        containerDuration: frames.duration,
                        layerNumber: i,
                        atEnd,
                        nextRefStart,
                        timeOffset: keyframe.time
                    });
                }
            }
        }
        fileRefs.reverse();
        return fileRefs;
    }
    zeroPad(num, size) {
        return (1e15 + num + "").slice(-size);
    }
    getReferencedUrl(keyframe, refBase) {
        let url;
        let assetPack;
        if (keyframe.value.ReferenceMode && keyframe.value.ReferenceMode.value === 'name') {
            let name = keyframe.value.KeysFileReference.name;
            let anim = Runtime_1.default.instance.animDB.getAnimByName(name);
            if (!anim) {
                throw new ReferenceError("AnimDB name lookup failed");
            }
            let parts = anim.resourceRoot.split('/node_modules/');
            if (parts.length > 1) {
                assetPack = parts[1];
            }
            else {
                assetPack = 'jibo-anim-db-animations';
            }
            url = path.join(anim.resourceRoot, anim.meta.path);
        }
        else {
            let filename = keyframe.value.KeysFileReference.file;
            assetPack = Runtime_1.default.instance.utils.PathUtils.getAssetPack(filename);
            url = Runtime_1.default.instance.utils.PathUtils.getAssetUri(filename, '', refBase);
        }
        return { url, assetPack };
    }
    removeHoldSafesInReferences(keyframes) {
        for (let layer of keyframes.layers) {
            if (layer.type === 'Event' && this.isReferencedLayer(layer)) {
                for (let keyframe of layer.keyframes) {
                    if (keyframe.value.Event.name === 'HOLD_SAFE') {
                        keyframe.value.Event.name = 'REFERENCED_HOLD_SAFE';
                    }
                }
            }
        }
    }
    removeReferenceLayers(keyframes) {
        for (let i = keyframes.layers.length - 1; i >= 0; i--) {
            const layer = keyframes.layers[i];
            if (layer.type === 'Reference') {
                keyframes.layers.splice(i, 1);
            }
        }
    }
    timeshift(frames, validFrom, validUpto, holdAfter) {
        for (let layer of frames.layers) {
            if (layer.validFrom === undefined) {
                layer.validFrom = validFrom;
                layer.validUpto = validUpto;
                layer.holdAfter = holdAfter;
            }
            else {
                layer.validFrom += validFrom;
                layer.validUpto += validFrom;
                layer.holdAfter += validFrom;
            }
            if (layer.validUpto > validUpto) {
                layer.validUpto = validUpto;
            }
            if (layer.holdAfter > holdAfter) {
                layer.holdAfter = holdAfter;
            }
            for (let keyframe of layer.keyframes) {
                keyframe.time += validFrom;
            }
        }
    }
    composite(layerNumber, existingKeyframes, toBeInsertedKeyframes) {
        for (let i = toBeInsertedKeyframes.layers.length - 1; i >= 0; i--) {
            existingKeyframes.layers.splice(layerNumber, 0, toBeInsertedKeyframes.layers[i]);
        }
    }
    fixLayerIds(frames, prefix) {
        let i = 0;
        for (let layer of frames.layers) {
            layer.id = `${prefix}-${layer.id}.${i}`;
            i++;
        }
    }
    isReferencedLayer(layer) {
        return layer.id.indexOf('-') >= 0;
    }
}
exports.default = KeysLoader;

},{"../../Runtime":1,"async":undefined,"jibo-keyframes":undefined,"path":undefined}],103:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const pixi_animate_1 = require("pixi-animate");
class Shapes {
    constructor(id, shapes) {
        pixi_animate_1.ShapesCache.add(id, shapes);
        this.id = id;
    }
    destroy() {
        pixi_animate_1.ShapesCache.remove(this.id);
    }
}
exports.default = Shapes;

},{"pixi-animate":undefined}],104:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class Spritesheet {
    constructor(baseTexture, frames, resolution) {
        this.baseTexture = baseTexture;
        if (resolution !== 1) {
            baseTexture.resolution = resolution;
            baseTexture.update();
        }
        this.frames = {};
        for (let name in frames) {
            let frame = frames[name];
            let rect = frame.frame;
            let trim = null;
            const orig = new PIXI.Rectangle(0, 0, frame.sourceSize.w / resolution, frame.sourceSize.h / resolution);
            const size = new PIXI.Rectangle(rect.x / resolution, rect.y / resolution, rect.w / resolution, rect.h / resolution);
            if (frame.rotated) {
                size.width = rect.h / resolution;
                size.height = rect.w / resolution;
            }
            if (frame.trimmed) {
                trim = new PIXI.Rectangle(frame.spriteSourceSize.x / resolution, frame.spriteSourceSize.y / resolution, rect.w / resolution, rect.h / resolution);
            }
            this.frames[name] = new PIXI.Texture(baseTexture, size, orig, trim, frame.rotate);
        }
    }
    destroy() {
        for (let name in this.frames) {
            this.frames[name].destroy();
        }
        this.frames = null;
        this.baseTexture.destroy();
    }
}
exports.default = Spritesheet;

},{}],105:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Texture = PIXI.Texture;
class Timeline {
    constructor() {
        this.textures = [];
        this.textureMap = new Map();
    }
    addTexture(texture, id) {
        Texture.addToCache(texture, id);
        this.textures.push(texture);
        this.textureMap.set(id, texture);
    }
    getTexture(id) {
        return this.textureMap.get(id);
    }
    addShapes(shapes) {
        this.shapes = shapes;
    }
    addSpritesheet(spritesheet) {
        for (let id in spritesheet.frames) {
            this.addTexture(spritesheet.frames[id], id);
            this.textureMap.set(id, spritesheet.frames[id]);
        }
    }
    upload(renderer, callback) {
        this.textures.forEach((texture) => {
            renderer.plugins.prepare.upload(texture);
        });
        renderer.plugins.prepare.upload(callback);
    }
    destroy() {
        if (this.textures) {
            this.textures.forEach((texture) => {
                Texture.removeFromCache(texture);
            });
            this.textures = null;
        }
        this.textureMap = null;
        if (this.shapes) {
            this.shapes.destroy();
            this.shapes = null;
        }
        this.library = null;
    }
}
exports.default = Timeline;

},{}],106:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Timeline_1 = require("./Timeline");
const Shapes_1 = require("./Shapes");
const KeysAnimation_1 = require("./KeysAnimation");
const KeysLoader_1 = require("./KeysLoader");
const Spritesheet_1 = require("./Spritesheet");
exports.default = {
    Timeline: Timeline_1.default,
    Shapes: Shapes_1.default,
    Spritesheet: Spritesheet_1.default,
    KeysAnimation: KeysAnimation_1.default,
    KeysLoader: KeysLoader_1.default
};

},{"./KeysAnimation":100,"./KeysLoader":102,"./Shapes":103,"./Spritesheet":104,"./Timeline":105}],107:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log_1 = require("../log");
exports.default = log_1.default.createChild('Animation');

},{"../log":162}],108:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const EyeMesh_1 = require("./EyeMesh");
const AbstractLayer_1 = require("./AbstractLayer");
const log_1 = require("./log");
class AbstractEye extends AbstractLayer_1.default {
    init(texture) {
        this.eyeMesh = new EyeMesh_1.default(texture);
        this.addChild(this.eyeMesh);
        super.init(texture);
    }
    destroy() {
        super.destroy();
        this.eyeMesh = null;
    }
    setTexture(texture) {
        log_1.default.debug('AbstractEye.setTexture - ' + log_1.simplifyTexture(texture));
        if (texture && texture.baseTexture) {
            super.setTexture(texture);
            this.eyeMesh.texture = texture;
        }
        else {
            this.reset(false);
        }
    }
}
exports.default = AbstractEye;

},{"./AbstractLayer":109,"./EyeMesh":114,"./log":120}],109:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../../Runtime");
const jibo_plugins_1 = require("jibo-plugins");
const log_1 = require("./log");
class AbstractLayer extends PIXI.Container {
    constructor(eyeContainer) {
        super();
        this.eyeContainer = eyeContainer;
        this.x = 0;
        this.y = 0;
        this.connected = true;
        this.initialized = false;
    }
    reset(resetPath) {
        if (this.initialized) {
            this._applyTexture(this._defaultTexture);
            if (resetPath !== false) {
                this._texturePath = this._defaultTexture.baseTexture.imageUrl;
            }
        }
    }
    init(texture) {
        this._defaultTexture = texture;
        this.initialized = true;
        this.reset();
        if (this.timestamp && this.dofValues) {
            this.display(this.timestamp, this.dofValues);
        }
    }
    display(timestamp, dofValues) {
        if (!this.initialized) {
            this.timestamp = timestamp;
            this.dofValues = dofValues;
            return false;
        }
        if (!this.connected) {
            return false;
        }
        return true;
    }
    set texturePath(value) {
        if (value !== this._texturePath) {
            this._texturePath = value;
            this._cancelLoad();
            if (!jibo_plugins_1.PathUtils.isImage(value)) {
                this.reset(false);
            }
            else {
                log_1.default.debug('AbstractLayer.set-texturePath', value);
                const texture = this.eyeContainer.getTexture(value);
                if (texture) {
                    this._applyTexture(texture);
                }
                else if (this._isDefaultTexture(this._defaultTexture, value)) {
                    this.reset();
                }
                else {
                    this._loadTexture(value);
                }
            }
        }
    }
    get texturePath() {
        return this._texturePath;
    }
    destroy() {
        if (this._destroyed) {
            return;
        }
        this._cancelLoad();
        this.reset();
        this._defaultTexture = null;
        this._texture = null;
        super.destroy({ children: true });
    }
    setTexture(texture) {
        this._texture = texture;
    }
    rgb2hex(red, green, blue) {
        return (red * 255) << 16 | (green * 255) << 8 | (blue * 255);
    }
    _isDefaultTexture(texture, value) {
        const parts = texture.baseTexture.imageUrl.split('animation-utilities');
        return parts.length === 2 && value.endsWith(parts[1]);
    }
    _cancelLoad() {
        if (this._load) {
            this._load.cancel();
            this._load = null;
        }
    }
    _applyTexture(texture) {
        const oldTexture = this._texture;
        if (oldTexture && this._textureToken) {
            this._textureToken.unload();
            this._textureToken = null;
        }
        this.setTexture(texture);
    }
    _loadTexture(value) {
        this._load = Runtime_1.default.instance.loader.load({
            id: value,
            src: value,
            cache: this.eyeContainer.CACHE_ID,
            type: 'texture',
            complete: (err, texture) => {
                const token = this._load.tokens[0];
                this._load = null;
                this._applyTexture(texture);
                this._textureToken = token;
            }
        });
    }
}
exports.default = AbstractLayer;

},{"../../Runtime":1,"./log":120,"jibo-plugins":undefined}],110:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const AbstractLayer_1 = require("./AbstractLayer");
const log_1 = require("./log");
class Background extends AbstractLayer_1.default {
    init(texture) {
        this.sprite = new PIXI.Sprite(texture);
        this.addChild(this.sprite);
        super.init(texture);
    }
    display(timestamp, dofValues) {
        if (!super.display(timestamp, dofValues)) {
            return false;
        }
        this.texturePath = dofValues.screenBGTextureInfixBn_r;
        this.sprite.tint = this.rgb2hex(dofValues.screenBG_redChannelBn_r, dofValues.screenBG_greenChannelBn_r, dofValues.screenBG_blueChannelBn_r);
        return true;
    }
    destroy() {
        super.destroy();
        this.sprite = null;
    }
    setTexture(texture) {
        super.setTexture(texture);
        log_1.default.debug('Background.setTexture', log_1.simplifyTexture(texture));
        if (texture && texture.baseTexture) {
            this.sprite.texture = texture;
        }
        else {
            this.reset(false);
        }
    }
}
exports.default = Background;

},{"./AbstractLayer":109,"./log":120}],111:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function isNotDirty(a, b) {
    if (!a || !b) {
        return false;
    }
    return a.eyeSubRootBn_t === b.eyeSubRootBn_t &&
        a.eyeSubRootBn_t_2 === b.eyeSubRootBn_t_2 &&
        a.vertexJoint1_t === b.vertexJoint1_t &&
        a.vertexJoint1_t_2 === b.vertexJoint1_t_2 &&
        a.vertexJoint2_t === b.vertexJoint2_t &&
        a.vertexJoint2_t_2 === b.vertexJoint2_t_2 &&
        a.vertexJoint3_t === b.vertexJoint3_t &&
        a.vertexJoint3_t_2 === b.vertexJoint3_t_2 &&
        a.vertexJoint4_t === b.vertexJoint4_t &&
        a.vertexJoint4_t_2 === b.vertexJoint4_t_2 &&
        a.vertexJoint5_t === b.vertexJoint5_t &&
        a.vertexJoint5_t_2 === b.vertexJoint5_t_2 &&
        a.vertexJoint6_t === b.vertexJoint6_t &&
        a.vertexJoint6_t_2 === b.vertexJoint6_t_2 &&
        a.vertexJoint7_t === b.vertexJoint7_t &&
        a.vertexJoint7_t_2 === b.vertexJoint7_t_2 &&
        a.vertexJoint8_t === b.vertexJoint8_t &&
        a.vertexJoint8_t_2 === b.vertexJoint8_t_2 &&
        a.vertexJoint9_t === b.vertexJoint9_t &&
        a.vertexJoint9_t_2 === b.vertexJoint9_t_2 &&
        a.eye_redChannelBn_r === b.eye_redChannelBn_r &&
        a.eye_greenChannelBn_r === b.eye_greenChannelBn_r &&
        a.eye_blueChannelBn_r === b.eye_blueChannelBn_r &&
        a.eye_alphaChannelBn_r === b.eye_alphaChannelBn_r &&
        a.eyeTextureInfixBn_r === b.eyeTextureInfixBn_r &&
        a.eyeSubRootBn_r === b.eyeSubRootBn_r &&
        a.eyeVisibilityBn_r === b.eyeVisibilityBn_r &&
        a.overlay_textureSubRootBn_t === b.overlay_textureSubRootBn_t &&
        a.overlay_textureSubRootBn_t_2 === b.overlay_textureSubRootBn_t_2 &&
        a.overlay_textureSubRootBn_r === b.overlay_textureSubRootBn_r &&
        a.overlay_vertexJoint1_t === b.overlay_vertexJoint1_t &&
        a.overlay_vertexJoint1_t_2 === b.overlay_vertexJoint1_t_2 &&
        a.overlay_vertexJoint2_t === b.overlay_vertexJoint2_t &&
        a.overlay_vertexJoint2_t_2 === b.overlay_vertexJoint2_t_2 &&
        a.overlay_vertexJoint3_t === b.overlay_vertexJoint3_t &&
        a.overlay_vertexJoint3_t_2 === b.overlay_vertexJoint3_t_2 &&
        a.overlay_vertexJoint4_t === b.overlay_vertexJoint4_t &&
        a.overlay_vertexJoint4_t_2 === b.overlay_vertexJoint4_t_2 &&
        a.overlay_vertexJoint5_t === b.overlay_vertexJoint5_t &&
        a.overlay_vertexJoint5_t_2 === b.overlay_vertexJoint5_t_2 &&
        a.overlay_vertexJoint6_t === b.overlay_vertexJoint6_t &&
        a.overlay_vertexJoint6_t_2 === b.overlay_vertexJoint6_t_2 &&
        a.overlay_vertexJoint7_t === b.overlay_vertexJoint7_t &&
        a.overlay_vertexJoint7_t_2 === b.overlay_vertexJoint7_t_2 &&
        a.overlay_vertexJoint8_t === b.overlay_vertexJoint8_t &&
        a.overlay_vertexJoint8_t_2 === b.overlay_vertexJoint8_t_2 &&
        a.overlay_vertexJoint9_t === b.overlay_vertexJoint9_t &&
        a.overlay_vertexJoint9_t_2 === b.overlay_vertexJoint9_t_2 &&
        a.overlay_redChannelBn_r === b.overlay_redChannelBn_r &&
        a.overlay_greenChannelBn_r === b.overlay_greenChannelBn_r &&
        a.overlay_blueChannelBn_r === b.overlay_blueChannelBn_r &&
        a.overlay_alphaChannelBn_r === b.overlay_alphaChannelBn_r &&
        a.overlayTextureInfixBn_r === b.overlayTextureInfixBn_r &&
        a.overlayVisibilityBn_r === b.overlayVisibilityBn_r &&
        a.screenBGTextureInfixBn_r === b.screenBGTextureInfixBn_r &&
        a.screenBG_redChannelBn_r === b.screenBG_redChannelBn_r &&
        a.screenBG_greenChannelBn_r === b.screenBG_greenChannelBn_r &&
        a.screenBG_blueChannelBn_r === b.screenBG_blueChannelBn_r &&
        a.lighting_amount === b.lighting_amount &&
        a.lighting_brightness === b.lighting_brightness &&
        a.lighting_gradient === b.lighting_gradient &&
        a.lighting_radius === b.lighting_radius &&
        a.lighting_light_redChannel === b.lighting_light_redChannel &&
        a.lighting_light_greenChannel === b.lighting_light_greenChannel &&
        a.lighting_light_blueChannel === b.lighting_light_blueChannel &&
        a.lighting_mid_redChannel === b.lighting_mid_redChannel &&
        a.lighting_mid_greenChannel === b.lighting_mid_greenChannel &&
        a.lighting_mid_blueChannel === b.lighting_mid_blueChannel &&
        a.lighting_dark_redChannel === b.lighting_dark_redChannel &&
        a.lighting_dark_greenChannel === b.lighting_dark_greenChannel &&
        a.lighting_dark_blueChannel === b.lighting_dark_blueChannel &&
        a.glow_amount === b.glow_amount &&
        a.glow_blur === b.glow_blur &&
        a.glow_halo === b.glow_halo &&
        a.glow_haloMaxDistance === b.glow_haloMaxDistance &&
        a.glow_redChannel === b.glow_redChannel &&
        a.glow_greenChannel === b.glow_greenChannel &&
        a.glow_blueChannel === b.glow_blueChannel;
}
exports.isNotDirty = isNotDirty;

},{}],112:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const AbstractEye_1 = require("./AbstractEye");
const jibo_keyframes_1 = require("jibo-keyframes");
const FaceRenderer_1 = require("../FaceRenderer");
class Eye extends AbstractEye_1.default {
    display(timestamp, dofValues) {
        if (!super.display(timestamp, dofValues)) {
            return false;
        }
        const points = this.eyeMesh.points;
        this.texturePath = dofValues.eyeTextureInfixBn_r;
        points[0].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.vertexJoint1_t);
        points[0].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.vertexJoint1_t_2);
        points[1].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.vertexJoint2_t);
        points[1].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.vertexJoint2_t_2);
        points[2].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.vertexJoint3_t);
        points[2].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.vertexJoint3_t_2);
        points[3].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.vertexJoint4_t);
        points[3].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.vertexJoint4_t_2);
        points[4].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.vertexJoint5_t);
        points[4].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.vertexJoint5_t_2);
        points[5].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.vertexJoint6_t);
        points[5].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.vertexJoint6_t_2);
        points[6].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.vertexJoint7_t);
        points[6].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.vertexJoint7_t_2);
        points[7].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.vertexJoint8_t);
        points[7].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.vertexJoint8_t_2);
        points[8].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.vertexJoint9_t);
        points[8].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.vertexJoint9_t_2);
        this.x = jibo_keyframes_1.conversion.toPixelsX(dofValues.eyeSubRootBn_t) + (FaceRenderer_1.default.WIDTH) / 2;
        this.y = -jibo_keyframes_1.conversion.toPixelsX(dofValues.eyeSubRootBn_t_2) + (FaceRenderer_1.default.HEIGHT) / 2;
        this.visible = dofValues.eyeVisibilityBn_r === undefined ? true : !!dofValues.eyeVisibilityBn_r;
        this.alpha = dofValues.eye_alphaChannelBn_r === undefined ? 1 : dofValues.eye_alphaChannelBn_r;
        this.eyeMesh.tint = this.rgb2hex(dofValues.eye_redChannelBn_r, dofValues.eye_greenChannelBn_r, dofValues.eye_blueChannelBn_r);
        this.rotation = -dofValues.eyeSubRootBn_r;
        return true;
    }
}
exports.default = Eye;

},{"../FaceRenderer":99,"./AbstractEye":108,"jibo-keyframes":undefined}],113:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Background_1 = require("./Background");
const Eye_1 = require("./Eye");
const EyeOverlay_1 = require("./EyeOverlay");
const DOFValues_1 = require("./DOFValues");
const KeysAnimation_1 = require("../animation/KeysAnimation");
const KeysAnimation_2 = require("../animation/KeysAnimation");
const FaceRenderer_1 = require("../FaceRenderer");
const GlowFilter_1 = require("./filters/glow/GlowFilter");
const LightFilter_1 = require("./filters/light/LightFilter");
const Runtime_1 = require("../../Runtime");
const jibo_plugins_1 = require("jibo-plugins");
const path = require("path");
const DEFAULT_TEXTURES = {
    EYE: "res/geometry-config/P1.0/textures/Default_Eye.png",
    EYE_OVERLAY: "res/geometry-config/P1.0/textures/JiBO_eye_customizer_44.png",
    BACKGROUND: "res/geometry-config/P1.0/textures/JiBO_BG_00.png"
};
const ANIM_REMOVAL_DELAY = 100;
class EyeContainer extends PIXI.Container {
    constructor() {
        super();
        this.CACHE_ID = 'global-eye';
        this._previousDofValues = null;
        this._currentDofValues = null;
        this._animation = null;
        this._animRemovalTimer = null;
        this._pendingAnim = null;
        this.backgroundBorder = new PIXI.Graphics();
        this._zoom = 1.0;
        this.eye = new Eye_1.default(this);
        this.eyeOverlay = new EyeOverlay_1.default(this);
        this.background = new Background_1.default(this);
        this.onAnimationStopped = this.onAnimationStopped.bind(this);
        this.onAnimationReorder = this.onAnimationReorder.bind(this);
        this.removeLastAnimAndReset = this.removeLastAnimAndReset.bind(this);
        this.removeLastAnimAndReset.isGlobalTimer = true;
        this.glow = new GlowFilter_1.default();
        this.lighting = new LightFilter_1.default();
        this.glow.target = this.eye;
        this.lighting.target = this.eye;
        this.lighting.lightPosition.set(FaceRenderer_1.default.WIDTH / 2, FaceRenderer_1.default.HEIGHT / 2);
        this.eye.filters = [this.lighting, this.glow];
        this.active = false;
    }
    init() {
        const loader = Runtime_1.default.instance.loader;
        loader.addCache(this.CACHE_ID);
        loader.load(this._getDefaultTextures(), {
            complete: (err, results) => {
                this.eyeOverlay.init(results.eyeOverlay);
                this.eye.init(results.eye);
                this.background.init(results.background);
            }
        });
    }
    addAnimation(anim) {
        if (this._pendingAnim && anim !== this._pendingAnim) {
            this._pendingAnim.destroyWhenComplete();
            this._pendingAnim = null;
        }
        if (anim === this._animation) {
            this.onAnimationReorder();
            return;
        }
        if (anim) {
            this.emit('addAnimation');
            this._pendingAnim = anim;
            this.holdCurrentAnim();
        }
        else {
            if (this._animation) {
                this.removeLastAnim();
            }
            this._animation = anim;
            this.reset();
        }
    }
    removeAnimation(anim) {
        if (anim !== this._animation) {
            return;
        }
        if (!this._pendingAnim) {
            this.emit('removeAnimation');
            this.queueAnimRemoval();
        }
    }
    holdCurrentAnim() {
        if (this._animRemovalTimer) {
            this._animRemovalTimer.destroy();
            this._animRemovalTimer = null;
        }
    }
    getTexture(value) {
        let texture = null;
        if (this._animation) {
            if (!this._animation.textures) {
                console.error(`Animation ${this._animation.id} has no textures and can't get ${value} - was the KeysData unloaded?`);
                return null;
            }
            texture = this._animation.textures[value] || null;
        }
        return texture;
    }
    set active(active) {
        this.connected = active;
        this.visible = active;
        this.removeLastAnim();
        this.reset();
    }
    display(timestamp, dofValues, meta) {
        if (this._destroyed) {
            return;
        }
        if (this._pendingAnim && meta.sourceTimes && meta.sourceTimes[this._pendingAnim.name]) {
            this.swapLastAnimForPending();
        }
        if (meta && meta.sourceTimes && this._animation) {
            this._animation.update(meta.sourceTimes[this._animation.name], dofValues);
        }
        if (this.connected) {
            this._previousDofValues = this._currentDofValues;
            this._currentDofValues = dofValues;
        }
        this.glow.animate();
        if (!DOFValues_1.isNotDirty(this._previousDofValues, this._currentDofValues)) {
            this.glow.update(timestamp, dofValues);
            this.lighting.update(timestamp, dofValues);
            this.eye.display(timestamp, dofValues);
            this.eyeOverlay.display(timestamp, dofValues);
            this.background.display(timestamp, dofValues);
        }
    }
    set zoom(zoom) {
        this._zoom = zoom;
        zoom = Math.min(zoom, 1);
        this.scale.x = zoom;
        this.scale.y = zoom;
        this.x = 0.5 * (FaceRenderer_1.default.WIDTH - zoom * FaceRenderer_1.default.WIDTH);
        this.y = 0.5 * (FaceRenderer_1.default.HEIGHT - zoom * FaceRenderer_1.default.HEIGHT);
    }
    get zoom() {
        return this._zoom;
    }
    makeBorder() {
        this.backgroundBorder.lineStyle(3, 0xFFFFFF)
            .moveTo(0, 0)
            .lineTo(FaceRenderer_1.default.WIDTH, 0)
            .lineTo(FaceRenderer_1.default.WIDTH, FaceRenderer_1.default.HEIGHT)
            .lineTo(0, FaceRenderer_1.default.HEIGHT)
            .lineTo(0, 0);
    }
    destroy() {
        this.removeLastAnim();
        this.eye.destroy();
        this.eye = null;
        this.eyeOverlay.destroy();
        this.eyeOverlay = null;
        this.background.destroy();
        this.background = null;
        this.backgroundBorder.destroy();
        this.backgroundBorder = null;
        super.destroy({ children: true });
    }
    reset() {
        if (this._animRemovalTimer) {
            this._animRemovalTimer.destroy();
            this._animRemovalTimer = null;
        }
        this.removeChildren();
        this.addChild(this.background);
        this.addChild(this.backgroundBorder);
        this.addChild(this.eye);
        this.addChild(this.eyeOverlay);
        this.eye.reset();
        this.eyeOverlay.reset();
        this.background.reset();
    }
    _getDefaultTextures() {
        const dir = path.dirname(path.dirname(jibo_plugins_1.PathUtils.resolve('animation-utilities', __dirname)));
        return [
            {
                id: "eye",
                src: path.join(dir, DEFAULT_TEXTURES.EYE),
                type: 'texture',
                cache: this.CACHE_ID
            },
            {
                id: "eyeOverlay",
                src: path.join(dir, DEFAULT_TEXTURES.EYE_OVERLAY),
                type: 'texture',
                cache: this.CACHE_ID
            },
            {
                id: "background",
                src: path.join(dir, DEFAULT_TEXTURES.BACKGROUND),
                type: 'texture',
                cache: this.CACHE_ID
            }
        ];
    }
    onAnimationReorder() {
        this.reset();
        this._animation.layers.forEach((layer) => {
            if (!(layer instanceof KeysAnimation_2.EyeLayer)) {
                const instance = layer.instance;
                this.addChild(instance);
            }
        });
    }
    onAnimationStopped() {
        this.reset();
    }
    queueAnimRemoval() {
        this.removeListenersAndDestroy(false);
        if (this._animRemovalTimer) {
            this._animRemovalTimer.destroy();
        }
        this._animRemovalTimer = Runtime_1.default.instance.timer.setTimeout(this.removeLastAnimAndReset, ANIM_REMOVAL_DELAY);
    }
    swapLastAnimForPending() {
        if (this._animRemovalTimer) {
            this._animRemovalTimer.destroy();
            this._animRemovalTimer = null;
        }
        if (this._animation) {
            this.removeListenersAndDestroy(true);
        }
        const anim = this._animation = this._pendingAnim;
        anim.on(KeysAnimation_1.default.STOPPED, this.onAnimationStopped);
        anim.on(KeysAnimation_1.default.REORDER, this.onAnimationReorder);
        this.onAnimationReorder();
        this._pendingAnim = null;
    }
    removeLastAnim() {
        if (this._animRemovalTimer) {
            this._animRemovalTimer.destroy();
            this._animRemovalTimer = null;
        }
        if (this._animation) {
            this.removeListenersAndDestroy(true);
        }
    }
    removeListenersAndDestroy(destroy) {
        this._animation.removeListener(KeysAnimation_1.default.STOPPED, this.onAnimationStopped);
        this._animation.removeListener(KeysAnimation_1.default.REORDER, this.onAnimationReorder);
        if (destroy) {
            this._animation.destroyWhenComplete();
            this._animation = null;
        }
    }
    removeLastAnimAndReset() {
        this.removeLastAnim();
        this.reset();
    }
}
exports.default = EyeContainer;

},{"../../Runtime":1,"../FaceRenderer":99,"../animation/KeysAnimation":100,"./Background":110,"./DOFValues":111,"./Eye":112,"./EyeOverlay":115,"./filters/glow/GlowFilter":116,"./filters/light/LightFilter":118,"jibo-plugins":undefined,"path":undefined}],114:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class EyeMesh extends PIXI.mesh.Mesh {
    constructor(texture) {
        super(texture, null, null, null, PIXI.mesh.Mesh.DRAW_MODES.TRIANGLES);
        this.uvs = new Float32Array([
            0, 0,
            0.5, 0,
            1, 0,
            0, 0.5,
            0.5, 0.5,
            1, 0.5,
            0, 1,
            0.5, 1,
            1, 1
        ]);
        this.vertices = new Float32Array(this.uvs.length * 2);
        this.points = [];
        for (let i = 0; i < this.uvs.length; i += 2) {
            this.points.push(new PIXI.Point(this.uvs[i], this.uvs[i + 1]));
        }
        this.indices = new Uint16Array([
            0, 1, 3,
            1, 3, 4,
            1, 4, 5,
            2, 5, 1,
            3, 4, 7,
            7, 6, 3,
            4, 5, 7,
            5, 7, 8
        ]);
    }
    updateTransform() {
        for (let i = 0; i < this.points.length; i++) {
            const point = this.points[i];
            const index = i * 2;
            this.vertices[index] = point.x;
            this.vertices[index + 1] = point.y;
        }
        this.containerUpdateTransform();
    }
}
exports.default = EyeMesh;

},{}],115:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const AbstractEye_1 = require("./AbstractEye");
const jibo_keyframes_1 = require("jibo-keyframes");
const FaceRenderer_1 = require("../FaceRenderer");
class EyeOverlay extends AbstractEye_1.default {
    display(timestamp, dofValues) {
        if (!super.display(timestamp, dofValues)) {
            return false;
        }
        const points = this.eyeMesh.points;
        this.texturePath = dofValues.overlayTextureInfixBn_r;
        points[0].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.overlay_vertexJoint1_t);
        points[0].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.overlay_vertexJoint1_t_2);
        points[1].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.overlay_vertexJoint2_t);
        points[1].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.overlay_vertexJoint2_t_2);
        points[2].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.overlay_vertexJoint3_t);
        points[2].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.overlay_vertexJoint3_t_2);
        points[3].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.overlay_vertexJoint4_t);
        points[3].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.overlay_vertexJoint4_t_2);
        points[4].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.overlay_vertexJoint5_t);
        points[4].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.overlay_vertexJoint5_t_2);
        points[5].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.overlay_vertexJoint6_t);
        points[5].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.overlay_vertexJoint6_t_2);
        points[6].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.overlay_vertexJoint7_t);
        points[6].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.overlay_vertexJoint7_t_2);
        points[7].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.overlay_vertexJoint8_t);
        points[7].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.overlay_vertexJoint8_t_2);
        points[8].x = jibo_keyframes_1.conversion.toPixelsX(dofValues.overlay_vertexJoint9_t);
        points[8].y = jibo_keyframes_1.conversion.toPixelsY(dofValues.overlay_vertexJoint9_t_2);
        this.x = jibo_keyframes_1.conversion.toPixelsX(dofValues.overlay_textureSubRootBn_t) + (FaceRenderer_1.default.WIDTH) / 2;
        this.y = -jibo_keyframes_1.conversion.toPixelsX(dofValues.overlay_textureSubRootBn_t_2) + (FaceRenderer_1.default.HEIGHT) / 2;
        this.eyeMesh.tint = this.rgb2hex(dofValues.overlay_redChannelBn_r, dofValues.overlay_greenChannelBn_r, dofValues.overlay_blueChannelBn_r);
        this.visible = dofValues.overlayVisibilityBn_r === undefined ? true : !!dofValues.overlayVisibilityBn_r;
        this.alpha = dofValues.overlay_alphaChannelBn_r === undefined ? 1 : dofValues.overlay_alphaChannelBn_r;
        this.rotation = -dofValues.overlay_textureSubRootBn_r;
        return true;
    }
}
exports.default = EyeOverlay;

},{"../FaceRenderer":99,"./AbstractEye":108,"jibo-keyframes":undefined}],116:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });

class GlowFilter extends PIXI.Filter {
    constructor() {
        super("#define GLSLIFY 1\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\nuniform vec4 filterArea;\nuniform vec2 center;\nuniform float haloScale;\n\nvarying vec2 vTextureCoord;\nvarying vec2 vTextureCoordScaled;\n\nvec2 mapCoord( vec2 coord )\n{\n    coord *= filterArea.xy;\n    coord += filterArea.zw;\n\n    return coord;\n}\n\nvec2 unmapCoord( vec2 coord )\n{\n    coord -= filterArea.zw;\n    coord /= filterArea.xy;\n\n    return coord;\n}\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n    vTextureCoord = aTextureCoord;\n\n    vec2 transl = mapCoord(aTextureCoord);\n\n    vec2 c = center;//vec2(1280.0/2.0, 720.0/2.0);\n\n    transl -= c;\n\n    transl *= haloScale;\n\n    transl += c ;\n\n    transl = unmapCoord(transl);\n\n//    center\n    vTextureCoordScaled = transl;\n}", "#define GLSLIFY 1\nvarying vec2 vTextureCoord;\nvarying vec2 vTextureCoordScaled;\n\nuniform sampler2D uSampler;\nuniform sampler2D uBlurSampler;\nuniform float amount;\nuniform float haloStrength;\nuniform vec4 glowColor;\n\nvoid main(void)\n{\n  vec4 original = texture2D(uSampler, vTextureCoord);\n  vec4 bluredNormal = texture2D(uBlurSampler, vTextureCoord);\n\n  vec4 originalScaled = texture2D(uSampler, vTextureCoordScaled);\n  vec4 bluredScaled = texture2D(uBlurSampler, vTextureCoordScaled);\n\n  float strength = 2.0;\n  float alpha = max(bluredNormal.a * strength, original.a);\n  alpha = min(alpha, 1.0);\n\n  vec4 color = glowColor * alpha;\n\n  color *= amount;\n\n  float knockout = bluredScaled.a * ( 1.0-originalScaled.a );\n  bluredScaled *= knockout;\n  bluredScaled *= 3.0;\n  bluredScaled *= haloStrength * amount;\n  bluredScaled = glowColor * bluredScaled.a;\n\n  gl_FragColor = color + (bluredScaled  * (1.0-color.a) );\n\n}");
        this.enabled = false;
        this.padding = 200;
        this.blurXFilter = new PIXI.filters.BlurXFilter();
        this.blurYFilter = new PIXI.filters.BlurYFilter();
        this.blendMode = PIXI.BLEND_MODES.ADD;
        this.defaultFilter = new PIXI.filters.AlphaFilter();
        this.uniforms.center.x = 0.1;
        this.uniforms.center.y = 0.1;
        this.uniforms.haloScale = 0.8;
        this.reset();
        this.target = null;
    }
    reset() {
        this.amount = 0;
        this.blur = 15;
        this.blurQuality = 4;
        this.haloSpeed = 0;
        this.halo = 0;
        this.haloMaxDistance = 80;
        this.color = 0x7df9ff;
    }
    apply(filterManager, input, output) {
        const target = this.target || filterManager.filterData.stack[filterManager.filterData.index].target;
        const renderTarget = filterManager.getRenderTarget(true);
        const renderTarget2 = filterManager.getRenderTarget(true);
        this.defaultFilter.apply(filterManager, input, output, false);
        this.defaultFilter.apply(filterManager, input, renderTarget, true);
        this.blurXFilter.apply(filterManager, renderTarget, renderTarget2, true);
        this.blurYFilter.apply(filterManager, renderTarget2, renderTarget, true);
        this.uniforms.center.x = target.position.x;
        this.uniforms.center.y = target.position.y;
        this.uniforms.uBlurSampler = renderTarget;
        const width = target.getBounds(true).width;
        this.uniforms.haloScale = 1 / ((width + this.haloDistance) / (width));
        filterManager.applyFilter(this, input, output, false);
        filterManager.returnRenderTarget(renderTarget);
        filterManager.returnRenderTarget(renderTarget2);
    }
    get blur() {
        return this.blurXFilter.blur;
    }
    set blur(value) {
        this.blurXFilter.blur = this.blurYFilter.blur = value;
    }
    set blurQuality(value) {
        this.blurXFilter.quality = value;
        this.blurYFilter.quality = value;
    }
    get blurQuality() {
        return this.blurXFilter.quality;
    }
    get halo() {
        return this._halo;
    }
    set halo(value) {
        this._halo = value;
        this.haloDistance = value * this.haloMaxDistance;
        this.uniforms.haloStrength = Math.sin(Math.PI * (1 - value));
    }
    get amount() {
        return this.uniforms.amount;
    }
    set amount(value) {
        this.enabled = value > 0;
        this.uniforms.amount = value;
    }
    get color() {
        return PIXI.utils.rgb2hex(this.uniforms.glowColor);
    }
    set color(value) {
        this.uniforms.glowColor = this.hex2rgba(value);
    }
    hex2rgba(value, alpha = 1) {
        const rgba = PIXI.utils.hex2rgb(value, this.uniforms.light);
        rgba[3] = alpha;
        return Array.prototype.slice.call(rgba);
    }
    update(timestamp, dofValues) {
        if (dofValues.glow_amount !== undefined) {
            this.setWithDOFS = true;
            this.amount = dofValues.glow_amount;
            this.blur = dofValues.glow_blur;
            this.halo = dofValues.glow_halo;
            this.haloMaxDistance = dofValues.glow_haloMaxDistance;
            this.color = dofValues.glow_redChannel << 16 |
                dofValues.glow_greenChannel << 8 |
                dofValues.glow_blueChannel;
        }
        else if (this.setWithDOFS) {
            this.setWithDOFS = false;
            this.reset();
        }
    }
    animate() {
        if (this.haloSpeed === 0) {
            return;
        }
        let value = this.halo + this.haloSpeed;
        if (value > 1) {
            value = 0;
        }
        else if (value < 0) {
            value = 1;
        }
        this.halo = value;
    }
}
exports.default = GlowFilter;

},{}],117:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const GlowFilter_1 = require("./glow/GlowFilter");
const LightFilter_1 = require("./light/LightFilter");
exports.default = {
    GlowFilter: GlowFilter_1.default,
    LightFilter: LightFilter_1.default
};

},{"./glow/GlowFilter":116,"./light/LightFilter":118}],118:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });

class LightFilter extends PIXI.Filter {
    constructor() {
        super("#define GLSLIFY 1\nattribute vec2 aVertexPosition;\nattribute vec2 aTextureCoord;\n\nuniform mat3 projectionMatrix;\n\nvarying vec2 vTextureCoord;\n\nvoid main(void)\n{\n    gl_Position = vec4((projectionMatrix * vec3(aVertexPosition, 1.0)).xy, 0.0, 1.0);\n    vTextureCoord = aTextureCoord;\n}", "#define GLSLIFY 1\nvarying vec2 vTextureCoord;\n\nuniform sampler2D uSampler;\nuniform float radius;\nuniform vec2 offset;\nuniform vec2 direction;\nuniform vec2 scale;\nuniform vec4 dark;\nuniform vec4 mid;\nuniform vec4 light;\nuniform vec4 filterArea;\nuniform float intensity;\nuniform float amount;\nuniform float gradientRatio;\n\nconst float PI = 3.141592657;\n\nvec2 mapCoord( vec2 coord )\n{\n    coord *= filterArea.xy;\n    coord += filterArea.zw;\n\n    return coord;\n}\n\nvec2 unmapCoord( vec2 coord )\n{\n    coord -= filterArea.zw;\n    coord /= filterArea.xy;\n\n    return coord;\n}\n\nfloat gradientLine ( float t, float b, float c, float d) {\n\n    return c * sin(t/d * (PI/2.0)) + b;\n    //return c * sqrt(1.0 - (t=t/d-1.0)*t) + b;\n}\n\nfloat gradient(vec2 coord)\n{\n    coord -= offset;\n\n    coord += direction;\n\n    coord *= scale;\n\n    float dist = length(coord);\n\n    float ratioDist = (radius - dist) / radius;\n    ratioDist = max(ratioDist, 0.0);\n    ratioDist = min(ratioDist, 1.0);\n\n    ratioDist = gradientLine(ratioDist, 0.0, ratioDist, 1.0);\n\n    return ratioDist;\n\n}\n\nvoid main(void)\n{\n\n    vec2 coord = mapCoord(vTextureCoord);\n\n    float lightGrad = gradient(coord);\n\n    vec4 original = texture2D(uSampler, vTextureCoord );\n\n    gl_FragColor = original;\n\n    vec4 blend = vec4(0.0);\n\n    if(lightGrad < gradientRatio)\n    {\n        float firstMix = (lightGrad / gradientRatio);\n        blend += mix(dark, mid, firstMix);// * step(firstMix, 1.0);\n    }\n    else\n    {\n        float secondMix = (lightGrad - gradientRatio)/(1.0-gradientRatio);\n        blend += mix(mid, light, secondMix);/// * step(1.0 - lightGrad, gradientRatio);\n    }\n\n    gl_FragColor *= blend;//mix(dark, light, lightGrad);\n    gl_FragColor.rgb += intensity*(1.0-lightGrad)* gl_FragColor.a;\n\n    gl_FragColor = mix(original, gl_FragColor, amount);\n}");
        this.enabled = false;
        this.reset();
        this.padding = 200;
        this.distanceMagnification = new PIXI.Point(300, 1100);
        this.lightPosition = new PIXI.Point();
        this.target = null;
    }
    reset() {
        this.amount = 1.1;
        this.radius = 250;
        this.gradientRatio = 0.53;
        this.lightScale = 0.98;
        this.dark = 0x5a5552;
        this.mid = 0xc0bab6;
        this.light = 0xffffff;
    }
    apply(filterManager, input, output) {
        const target = this.target || filterManager.filterData.stack[filterManager.filterData.index].target;
        const bounds = target.getBounds(true);
        this.uniforms.offset.x = target.position.x;
        this.uniforms.offset.y = target.position.y;
        this.uniforms.radius = this.radius;
        this.uniforms.scale.x = (this.radius / bounds.width) / this.lightScale;
        this.uniforms.scale.y = (this.radius / bounds.height) / this.lightScale;
        const centerX = target.position.x - this.lightPosition.x;
        const centerY = target.position.y - this.lightPosition.y;
        let dist = Math.sqrt(centerX * centerX + centerY * centerY);
        if (!dist) {
            dist = 0.001;
        }
        const nx = centerX / dist;
        const ny = centerY / dist;
        const intensityX = this.map(dist, 0, 500, 0, this.distanceMagnification.x);
        const intensityY = this.map(dist, 0, 500, 0, this.distanceMagnification.y);
        this.uniforms.direction.x = nx * -intensityX;
        this.uniforms.direction.y = ny * -intensityY;
        filterManager.applyFilter(this, input, output, false);
    }
    map(val, inputMin, inputMax, outputMin, outputMax) {
        return ((outputMax - outputMin) * ((val - inputMin) / (inputMax - inputMin))) + outputMin;
    }
    get dark() {
        return PIXI.utils.rgb2hex(this.uniforms.dark);
    }
    set dark(value) {
        this.uniforms.dark = this.hex2rgba(value, this.uniforms.dark);
    }
    get mid() {
        return PIXI.utils.rgb2hex(this.uniforms.mid);
    }
    set mid(value) {
        this.uniforms.mid = this.hex2rgba(value, this.uniforms.mid);
    }
    get light() {
        return PIXI.utils.rgb2hex(this.uniforms.light);
    }
    set light(value) {
        this.uniforms.light = this.hex2rgba(value, this.uniforms.light);
    }
    get amount() {
        return this.uniforms.amount;
    }
    set amount(value) {
        this.enabled = value > 0;
        this.uniforms.amount = value;
    }
    get brightness() {
        return this.uniforms.intensity;
    }
    set brightness(value) {
        this.uniforms.intensity = value;
    }
    get gradientRatio() {
        return this.uniforms.gradientRatio;
    }
    set gradientRatio(value) {
        this.uniforms.gradientRatio = value;
    }
    hex2rgba(value, current, alpha = 1) {
        const rgba = PIXI.utils.hex2rgb(value, current);
        rgba[3] = alpha;
        return Array.prototype.slice.call(rgba);
    }
    update(timestamp, dofValues) {
        const eyeTexturePath = dofValues.eyeTextureInfixBn_r;
        if (eyeTexturePath.endsWith("Default_Eye.png") ||
            eyeTexturePath.endsWith("White_Eye.png") ||
            eyeTexturePath.endsWith("white-eye.png")) {
            this.amount = 1.1;
        }
        else {
            this.amount = 0;
        }
    }
}
exports.default = LightFilter;

},{}],119:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const AbstractEye_1 = require("./AbstractEye");
const Background_1 = require("./Background");
const Eye_1 = require("./Eye");
const EyeMesh_1 = require("./EyeMesh");
const EyeOverlay_1 = require("./EyeOverlay");
const EyeContainer_1 = require("./EyeContainer");
const AbstractLayer_1 = require("./AbstractLayer");
const filters_1 = require("./filters");
exports.default = {
    AbstractEye: AbstractEye_1.default,
    Background: Background_1.default,
    Eye: Eye_1.default,
    EyeMesh: EyeMesh_1.default,
    EyeOverlay: EyeOverlay_1.default,
    EyeContainer: EyeContainer_1.default,
    AbstractLayer: AbstractLayer_1.default,
    filters: filters_1.default
};

},{"./AbstractEye":108,"./AbstractLayer":109,"./Background":110,"./Eye":112,"./EyeContainer":113,"./EyeMesh":114,"./EyeOverlay":115,"./filters":117}],120:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log_1 = require("../log");
exports.default = log_1.default.createChild('Eye');
function simplifyTexture(texture) {
    if (!texture) {
        return '[Texture NO TEXTURE]';
    }
    let frame = texture.frame ? `(${texture.frame.x}, ${texture.frame.y}, ${texture.frame.width}, ${texture.frame.height})` : 'NO FRAME';
    let url = texture.baseTexture ? texture.baseTexture.imageUrl : 'NO BASE TEXTURE';
    return `[Texture frame=${frame} url=${url}]`;
}
exports.simplifyTexture = simplifyTexture;

},{"../log":162}],121:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../../Runtime");
const ViewManager_1 = require("./ViewManager");
const ActionData_1 = require("./actions/ActionData");
const TouchInteractive_1 = require("./components/subcomponents/TouchInteractive");
const TouchManager_1 = require("./TouchManager");
const events_1 = require("events");
const log_1 = require("./log");
const log = log_1.default.createChild('Component');
class Component extends events_1.EventEmitter {
    constructor() {
        super(...arguments);
        this.id = '';
        this.parentGroup = null;
        this._stateChanged = false;
        this._type = '';
        this._assetDescriptors = null;
        this._assets = null;
        this._inputLocked = true;
        this._parentView = null;
        this._touchInteractivity = null;
        this._subcomponents = null;
    }
    get stateChanged() {
        return this._stateChanged;
    }
    get type() { return this._type; }
    get inputLocked() {
        return this._inputLocked;
    }
    set inputLocked(flag) {
        log.warn('Deprecation: the ability to set inputLocked is deprecated, please use lockInput(true|false) instead');
        this.lockInput(flag);
    }
    get assetDescriptors() {
        return this._assetDescriptors;
    }
    get parentView() {
        if (this._parentView) {
            return this._parentView;
        }
        let group = this;
        while (group.parentGroup) {
            group = group.parentGroup;
        }
        if (group instanceof Runtime_1.default.instance.face.views.View) {
            this._parentView = group;
            return this._parentView;
        }
        else {
            log.info('Component is not yet parented to a View.');
            return null;
        }
    }
    addSubcomponent(subcomponent) {
        if (!this._subcomponents) {
            this._subcomponents = {};
        }
        subcomponent.init(this);
        this._subcomponents[subcomponent.type] = subcomponent;
        return subcomponent;
    }
    getSubcomponent(type) {
        return this._subcomponents ? this._subcomponents[type] : null;
    }
    assignConfig(configData) {
        if (configData) {
            if (configData.hasOwnProperty('id')) {
                if (!this.id) {
                    this.id = configData.id;
                }
            }
            if (configData.hasOwnProperty('type')) {
                this._type = configData.type;
            }
            if (configData.hasOwnProperty('assets')) {
                if (!this._assetDescriptors) {
                    this._assetDescriptors = [];
                }
                this._assetDescriptors = this._assetDescriptors.concat(configData.assets);
            }
            if (configData.hasOwnProperty('action')) {
                this.addAction(ActionData_1.default.createFromConfig(configData.action));
            }
            else if (configData.hasOwnProperty('actions')) {
                for (let i = 0; i < configData.actions.length; i++) {
                    this.addAction(ActionData_1.default.createFromConfig(configData.actions[i]));
                }
            }
        }
    }
    registerUpdate(bool) {
        if (this.parentGroup) {
            if (bool) {
                this.parentGroup.registerComponentUpdate(this);
            }
            else {
                this.parentGroup.unregisterComponentUpdate(this);
            }
        }
    }
    destroy() {
        this.removeAllListeners();
        this._assetDescriptors = null;
        this._assets = null;
        if (this._subcomponents) {
            for (let key in this._subcomponents) {
                if (this._subcomponents.hasOwnProperty(key)) {
                    this._subcomponents[key].destroy();
                }
            }
            this._subcomponents = null;
        }
        this._touchInteractivity = null;
        this.parentGroup = null;
    }
    open(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME) {
        callback();
    }
    close(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME) {
        callback();
    }
    addAssetDescriptor(id, src, type, upload = false, cache = undefined) {
        return this.addAssetDescriptorObject({
            id: id,
            src: src,
            type: type,
            upload: upload,
            cache: cache
        });
    }
    addAssetDescriptorObject(assetDescriptor) {
        if (!this._assetDescriptors) {
            this._assetDescriptors = [];
        }
        return this._assetDescriptors.push(assetDescriptor);
    }
    get hasTouchInteractive() {
        return (this._touchInteractivity !== null);
    }
    get isTouchInteractive() {
        return (this._touchInteractivity && this._touchInteractivity.isActive);
    }
    addAction(action, data, clearPrevious = false, toFront = false, gesture = TouchManager_1.GESTURE.TAP) {
        if (!this._touchInteractivity) {
            this._touchInteractivity = this.addSubcomponent(new TouchInteractive_1.default());
            this._touchInteractivity.isActive = !this._inputLocked;
        }
        let actionData;
        if (typeof action === 'string') {
            actionData = new ActionData_1.default(action, data);
        }
        else {
            actionData = action;
            if (data) {
                actionData.data = data;
            }
        }
        return this._touchInteractivity.addAction(actionData, clearPrevious, toFront, gesture);
    }
    clearActions(gesture = TouchManager_1.GESTURE.TAP) {
        if (this._touchInteractivity) {
            this._touchInteractivity.clearActions(gesture);
        }
    }
    removeActionsByType(actionType, gesture = TouchManager_1.GESTURE.TAP) {
        if (this._touchInteractivity) {
            const actions = this._touchInteractivity.getActions(gesture);
            if (actions) {
                for (let i = actions.length - 1; i >= 0; i--) {
                    if (actions[i].type === actionType) {
                        actions.splice(i, 1);
                    }
                }
            }
        }
    }
    triggerActions(gesture = TouchManager_1.GESTURE.TAP) {
        if (this._touchInteractivity) {
            return this._touchInteractivity.triggerActions(gesture);
        }
        return false;
    }
    getActions(gesture = TouchManager_1.GESTURE.TAP) {
        if (this._touchInteractivity) {
            return this._touchInteractivity.getActions(gesture);
        }
    }
    hasActions(gesture = TouchManager_1.GESTURE.TAP) {
        return (this._touchInteractivity && this._touchInteractivity.hasActions(gesture));
    }
    lockInput(flag) {
        this._inputLocked = flag;
        if (this._touchInteractivity) {
            this._touchInteractivity.isActive = !flag;
        }
    }
}
exports.default = Component;

},{"../../Runtime":1,"./TouchManager":125,"./ViewManager":127,"./actions/ActionData":130,"./components/subcomponents/TouchInteractive":147,"./log":149,"events":undefined}],122:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../../Runtime");
const ViewState_1 = require("./ViewState");
const log_1 = require("./log");
const log = log_1.default.createChild('ComponentCreator');
class ComponentCreator {
    constructor() {
        this._classRegistry = {};
        if (!ComponentCreator._instance) {
            ComponentCreator._instance = this;
        }
    }
    get DEFAULT_VIEW() { return 'View'; }
    static get instance() {
        return ComponentCreator._instance;
    }
    createView(viewClass, config) {
        return this.createViewFromState(this.createViewState(viewClass, config));
    }
    createViewFromConfigObject(config) {
        if (config) {
            const viewState = new ViewState_1.default();
            viewState.applyConfig(config);
            return this.createViewFromState(viewState);
        }
        else {
            log.info('createViewFromConfigObject() config Object given was undefined');
            return null;
        }
    }
    createViewFromConfigPath(configPath, complete, failure) {
        if (configPath) {
            Runtime_1.default.instance.loader.load(configPath, (err, result) => {
                if (err) {
                    log.error('createViewFromConfigPath() cannot create View, error loading configuration at: ' + configPath + ' error:', err);
                    if (failure) {
                        failure('Unable to load config file ' + configPath);
                    }
                    return;
                }
                complete(this.createViewFromConfigObject(result));
            });
        }
        else {
            log.error('createViewFromConfigPath() config path given was undefined, cannot make View.');
            if (failure) {
                failure('Configuration path was not given');
            }
        }
    }
    createViewState(viewClass, config) {
        let viewState;
        if (typeof viewClass === 'string') {
            if (this._classRegistry.hasOwnProperty(viewClass)) {
                viewState = new ViewState_1.default(viewClass);
            }
            else {
                viewState = new ViewState_1.default(this.DEFAULT_VIEW);
            }
        }
        else if (viewClass && (typeof viewClass === 'object' || typeof viewClass === 'function')) {
            this.registerClass(viewClass);
            viewState = new ViewState_1.default(viewClass.name);
        }
        else {
            viewState = new ViewState_1.default(this.DEFAULT_VIEW);
        }
        if (typeof config === 'string') {
            viewState.configPath = config;
        }
        if (typeof config === 'object') {
            viewState.applyConfig(config);
        }
        return viewState;
    }
    createViewFromState(viewState) {
        if (viewState) {
            let viewClass = this.getClassFromRegistry(viewState.viewClassName);
            if (viewClass !== null) {
                let view = new viewClass();
                view.applyState(viewState);
                return view;
            }
            else {
                log.error('createViewFromState() class ' + viewState.viewClassName +
                    ' not found in registry, make sure class is registered before trying to create it.');
                return null;
            }
        }
        else {
            log.error('createViewFromState() provided viewState was null, must provide a valid ViewState');
            return null;
        }
    }
    createComponentFromConfig(componentConfig) {
        if (componentConfig.hasOwnProperty('type')) {
            let componentClass = this._classRegistry[componentConfig.type];
            if (componentClass) {
                return componentClass.createFromConfig(componentConfig);
            }
            else {
                log.warn('createComponentFromConfig() given invalid component type: ' + componentConfig.type);
                return null;
            }
        }
        else {
            log.warn('createComponentFromConfig() type was not specified.');
            return null;
        }
    }
    registerClass(componentClass, classType) {
        let classKey = classType;
        if (!classKey && componentClass.hasOwnProperty('DEFAULT_TYPE')) {
            classKey = componentClass.DEFAULT_TYPE;
        }
        if (classKey) {
            if (!this._classRegistry.hasOwnProperty(classKey)) {
                this._classRegistry[classKey] = componentClass;
            }
            else {
                log.info('registryClass() : class was already registered for name: ' + classKey);
            }
        }
        else {
            log.warn('registerClass() : No valid class key was given: ' + classKey +
                '. Attempting to register a class without providing a key will cause a failure when attempting to retrieve/use that class later');
        }
    }
    unregisterClass(classType) {
        if (this._classRegistry.hasOwnProperty(classType)) {
            delete this._classRegistry[classType];
        }
        else {
            log.info('unregisterClass() found no class registered for name: ' + classType);
        }
    }
    getClassFromRegistry(className) {
        if (this._classRegistry.hasOwnProperty(className)) {
            return this._classRegistry[className];
        }
        else {
            log.warn('getClassFromRegistry() no class found in registry with name: ' + className);
            return null;
        }
    }
}
exports.default = ComponentCreator;

},{"../../Runtime":1,"./ViewState":129,"./log":149}],123:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Component_1 = require("./Component");
const ComponentCreator_1 = require("./ComponentCreator");
const ViewManager_1 = require("./ViewManager");
const async = require("async");
const log_1 = require("./log");
const log = log_1.default.createChild('ComponentGroup');
class ComponentGroup extends Component_1.default {
    constructor() {
        super(...arguments);
        this.componentLibrary = {};
        this.componentList = [];
        this._childInputLocked = true;
    }
    get componentsTotal() {
        if (this.componentList) {
            return this.componentList.length;
        }
        return 0;
    }
    get assetDescriptors() {
        return this.groupAssetDescriptors;
    }
    get groupAssetDescriptors() {
        let groupAssetDescriptors = (this._assetDescriptors) ? this._assetDescriptors.slice(0) : [];
        if (this.componentList) {
            let i = 0;
            let length = this.componentList.length;
            let component;
            let nextAssetDescriptors;
            for (i; i < length; i++) {
                component = this.componentList[i];
                nextAssetDescriptors = component.assetDescriptors;
                if (nextAssetDescriptors) {
                    groupAssetDescriptors = groupAssetDescriptors.concat(nextAssetDescriptors);
                }
            }
        }
        return groupAssetDescriptors;
    }
    lockInput(flag) {
        super.lockInput(flag);
        this.lockChildInput(flag);
    }
    lockChildInput(flag) {
        if (this._childInputLocked !== flag) {
            this._childInputLocked = flag;
            if (this.componentList) {
                let component;
                let length = this.componentList.length;
                for (let i = 0; i < length; i++) {
                    component = this.componentList[i];
                    component.lockInput(flag);
                }
            }
        }
    }
    updateConfig(configObject) {
        if (this.updateComponentConfigs()) {
            this._stateChanged = true;
            Object.assign(configObject, { "componentConfigs": this.componentConfigs });
        }
        return configObject;
    }
    createComponentsFromConfigs(componentConfigs) {
        if (componentConfigs) {
            let creator = ComponentCreator_1.default.instance;
            let component;
            let length = componentConfigs.length;
            for (let i = 0; i < length; i++) {
                component = creator.createComponentFromConfig(componentConfigs[i]);
                if (component) {
                    this.addComponent(component);
                }
            }
        }
    }
    addComponent(component, componentId) {
        if (component) {
            component.parentGroup = this;
            if (!this.componentLibrary) {
                this.componentLibrary = {};
            }
            if (!this.componentList) {
                this.componentList = [];
            }
            if (componentId) {
                component.id = componentId;
            }
            if (!component.id) {
                let j = 1;
                while (this.componentLibrary.hasOwnProperty(String(component.type + j))) {
                    j++;
                }
                this.componentLibrary[String(component.type + j)] = component;
                this.componentList.push(component);
            }
            else {
                this.componentLibrary[component.id] = component;
                this.componentList.push(component);
            }
        }
        return component;
    }
    getIndexOfComponent(component) {
        return this.componentList.indexOf(component);
    }
    removeComponent(componentDeterminer) {
        let component;
        if (componentDeterminer instanceof Component_1.default) {
            component = componentDeterminer;
            const index = this.componentList.indexOf(component);
            if (index > -1) {
                this.componentList.splice(index, 1);
                this.componentLibrary[component.id] = null;
            }
            else {
                log.warn('removeComponent() Component not found:', componentDeterminer);
                return null;
            }
        }
        else if (typeof componentDeterminer === 'number') {
            component = this.componentList.splice(componentDeterminer, 1)[0];
            this.componentLibrary[component.id] = null;
        }
        else if (typeof componentDeterminer === 'string') {
            component = this.componentLibrary[componentDeterminer];
            if (component) {
                this.componentList.splice(this.componentList.indexOf(component), 1);
                this.componentLibrary[component.id] = null;
            }
            else {
                log.warn('removeComponent() Component not found with id: ' + componentDeterminer);
                return null;
            }
        }
        else {
            log.warn('removeComponent() Must pass Component, number, or string. Was given:', componentDeterminer);
            return null;
        }
        return component;
    }
    getComponentById(componentId) {
        if (this.componentLibrary) {
            return this.componentLibrary[componentId];
        }
        else {
            log.debug("getComponentById() this.componentLibrary is undefined, meaning no components have been added");
        }
    }
    getComponentByIndex(index) {
        if (this.componentList) {
            if (index > -1 && index < this.componentList.length) {
                return this.componentList[index];
            }
            else {
                log.warn('getComponentByIndex() index ' + index + ' is out of bounds, must be under ' + this.componentList.length);
            }
        }
        else {
            log.warn('getComponentByIndex() this.componentList is undefined, meaning no components have been added');
        }
        return null;
    }
    findComponent(testFunction, against) {
        if (testFunction(this, against)) {
            return this;
        }
        else if (this.componentList) {
            let component;
            let foundComponent;
            let length = this.componentList.length;
            for (let i = 0; i < length; i++) {
                component = this.componentList[i];
                if (component instanceof ComponentGroup) {
                    foundComponent = component.findComponent(testFunction, against);
                    if (foundComponent) {
                        return foundComponent;
                    }
                }
                else {
                    if (testFunction(component, against)) {
                        return component;
                    }
                }
            }
        }
        return null;
    }
    update(elapsed) {
        if (this._updateRegistry) {
            let length = this._updateRegistry.length;
            for (let i = 0; i < length; i++) {
                this._updateRegistry[i].update(elapsed);
            }
        }
    }
    registerComponentUpdate(component) {
        if (!this._updateRegistry) {
            this._updateRegistry = [];
        }
        this._updateRegistry.push(component);
    }
    unregisterComponentUpdate(component) {
        if (this._updateRegistry) {
            for (let i = 0; i < this._updateRegistry.length; i++) {
                if (this._updateRegistry[i] === component) {
                    this._updateRegistry.splice(i, 1);
                }
            }
        }
    }
    createDisplay(container, assets) {
        this.container = container;
        if (this.componentList) {
            const length = this.componentList.length;
            for (let i = 0; i < length; i++) {
                this.componentList[i].createDisplay(container, assets);
            }
        }
    }
    ready() {
        if (this.componentList) {
            const length = this.componentList.length;
            for (let i = 0; i < length; i++) {
                this.componentList[i].ready();
            }
        }
    }
    open(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME) {
        this.openChildren(callback, transitionType, duration);
    }
    close(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME) {
        this.closeChildren(callback, transitionType, duration);
    }
    openChildren(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME) {
        if (this.componentList) {
            let transitionArray = [];
            let i = 0;
            let length = this.componentList.length;
            for (i; i < length; i++) {
                let component = this.componentList[i];
                transitionArray.push(function (subCallback) {
                    component.open(subCallback, transitionType, duration);
                });
            }
            if (transitionArray.length > 0) {
                async.parallel(transitionArray, function (err, results) {
                    if (err) {
                        log.error('openChildren() encountered error', err);
                    }
                    this.transitionComplete(callback, err, results);
                }.bind(this));
            }
            else {
                this.transitionComplete(callback);
            }
        }
        else {
            this.transitionComplete(callback);
        }
    }
    closeChildren(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME) {
        if (this.componentList) {
            let transitionArray = [];
            let i = 0;
            let length = this.componentList.length;
            for (i; i < length; i++) {
                let component = this.componentList[i];
                transitionArray.push(function (subCallback) {
                    component.close(subCallback, transitionType, duration);
                });
            }
            if (transitionArray.length > 0) {
                async.parallel(transitionArray, function (err, results) {
                    if (err) {
                        log.error('closeChildren() encountered error', err);
                    }
                    this.transitionComplete(callback, err, results);
                }.bind(this));
            }
            else {
                this.transitionComplete(callback);
            }
        }
        else {
            this.transitionComplete(callback);
        }
    }
    actionHandler(action, fromComponent) {
        this.parentGroup.actionHandler(action, fromComponent);
    }
    actionEnactor(action) {
        let actionActedOn = false;
        if (!this.inputLocked) {
            if (this.componentList) {
                let component;
                let length = this.componentList.length;
                for (let i = 0; i < length; i++) {
                    component = this.componentList[i];
                    if (component instanceof ComponentGroup) {
                        if (component.actionEnactor(action)) {
                            actionActedOn = true;
                        }
                    }
                }
            }
        }
        return actionActedOn;
    }
    destroy() {
        if (this.componentList) {
            let length = this.componentList.length;
            for (let i = 0; i < length; i++) {
                this.componentList[i].destroy();
            }
        }
        this.container = null;
        this.componentLibrary = null;
        this.componentList = null;
        this.componentConfigs = null;
        this._updateRegistry = null;
        super.destroy();
    }
    transitionComplete(callback, err, results) {
        if (err) {
            log.error('transitionComplete() error during transition, error', err);
        }
        callback();
    }
    updateComponentConfigs() {
        let componentChanged = false;
        if (this.componentList && this.componentConfigs) {
            let length = this.componentList.length;
            let component;
            for (let i = 0; i < length; i++) {
                component = this.componentList[i];
                if (component.stateChanged) {
                    componentChanged = true;
                    component.updateConfig(this.componentConfigs[i]);
                }
            }
        }
        return componentChanged;
    }
}
exports.default = ComponentGroup;

},{"./Component":121,"./ComponentCreator":122,"./ViewManager":127,"./log":149,"async":undefined}],124:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const FaceRenderer_1 = require("../FaceRenderer");
class DisplayUtils {
    static getScaleByWidthHeight(displayObject, width, height) {
        const rect = displayObject.getBounds();
        return Math.max(width / rect.width * displayObject.scale.x, height / rect.height * displayObject.scale.y);
    }
    static isContained(display, container) {
        let parent = display.parent;
        while (parent) {
            if (parent === container) {
                return true;
            }
            parent = parent.parent;
        }
        return false;
    }
    static getElementPosition(position) {
        let point = new PIXI.Point(0, 0);
        let margin = { x: 0, y: 0 };
        if (position.margin) {
            isNaN(position.margin) ? Object.assign(margin, position.margin) : Object.assign(margin, { x: Number(position.margin), y: Number(position.margin) });
        }
        margin.x = isNaN(margin.x) ? 0 : margin.x;
        margin.y = isNaN(margin.y) ? 0 : margin.y;
        if (!isNaN(position.x)) {
            point.x = Number(position.x) + margin.x;
        }
        else if (DisplayUtils.CENTER === position.x) {
            point.x = FaceRenderer_1.default.WIDTH / 2;
        }
        else if (DisplayUtils.LEFT === position.x) {
            point.x = margin.x;
        }
        else if (DisplayUtils.RIGHT === position.x) {
            point.x = FaceRenderer_1.default.WIDTH - margin.x;
        }
        if (!isNaN(position.y)) {
            point.y = Number(position.y) + margin.y;
        }
        else if (DisplayUtils.CENTER === position.y) {
            point.y = FaceRenderer_1.default.HEIGHT / 2;
        }
        else if (DisplayUtils.TOP === position.y) {
            point.y = margin.y;
        }
        else if (DisplayUtils.BOTTOM === position.y) {
            point.y = FaceRenderer_1.default.HEIGHT - margin.y;
        }
        return point;
    }
}
DisplayUtils.LEFT = 'LEFT';
DisplayUtils.RIGHT = 'RIGHT';
DisplayUtils.CENTER = 'CENTER';
DisplayUtils.TOP = 'TOP';
DisplayUtils.BOTTOM = 'BOTTOM';
exports.default = DisplayUtils;

},{"../FaceRenderer":99}],125:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../../Runtime");
const GestureManager_1 = require("../input/GestureManager");
const FaceRenderer_1 = require("../FaceRenderer");
const log_1 = require("./log");
const log = log_1.default.createChild('TouchManager');
var GESTURE;
(function (GESTURE) {
    GESTURE["TAP"] = "tap";
    GESTURE["SWIPE_DOWN"] = "swipeDown";
    GESTURE["SWIPE"] = "swipeDown";
    GESTURE["SWIPE_UP"] = "swipeUp";
    GESTURE["PAN"] = "pan";
})(GESTURE = exports.GESTURE || (exports.GESTURE = {}));
class TouchManager {
    constructor(renderer, viewManager) {
        this.GESTURE = GESTURE;
        this._interactionManager = null;
        this._canvas = null;
        this._gestureManager = null;
        this._viewManager = null;
        this._tapGesture = null;
        this._swipeDownGesture = null;
        this._swipeUpGesture = null;
        this._panHorizontalGesture = null;
        this._interactionEvent = null;
        this._elementHit = null;
        this._isSim = false;
        this._prevX = null;
        this._prevY = null;
        this._isEmulatingPan = false;
        this._isMouseDown = false;
        if (!TouchManager._instance) {
            this._isSim = (Runtime_1.default.instance.runMode === Runtime_1.default.instance.RunMode.SIMULATOR);
            TouchManager._instance = this;
            this._interactionManager = renderer['plugins'].interaction;
            this._viewManager = viewManager;
            this._canvas = renderer.view;
            if (this._isSim) {
                this.onViewportOut = this.onViewportOut.bind(this);
            }
            else {
                this.onCoreTouchEvent = this.onCoreTouchEvent.bind(this);
            }
            this.checkElementHit = this.checkElementHit.bind(this);
        }
    }
    static get instance() {
        return TouchManager._instance;
    }
    init() {
        this._gestureManager = Runtime_1.default.instance.face.gestures;
        this._interactionEvent = {
            data: {
                global: new PIXI.Point()
            }
        };
        if (this._isSim) {
            this.addViewportOut();
        }
    }
    addGesture(gesture = GESTURE.TAP, gestureEventCallback) {
        switch (gesture) {
            case GESTURE.TAP:
                this.createTapGesture();
                break;
            case GESTURE.SWIPE_DOWN:
                this.createSwipeDownGesture();
                break;
            case GESTURE.SWIPE_UP:
                this.createSwipeUpGesture();
                break;
            case GESTURE.PAN:
                this.createPanHorizontalGesture(gestureEventCallback);
                break;
            default:
                log.warn('addGesture() passed: ' + gesture + ' which is not supported.');
                break;
        }
    }
    removeGesture(gesture = GESTURE.TAP) {
        switch (gesture) {
            case GESTURE.TAP:
                if (this._tapGesture) {
                    this._gestureManager.removeStageGesture(this._tapGesture);
                    this._tapGesture = null;
                }
                break;
            case GESTURE.SWIPE_DOWN:
                if (this._swipeDownGesture) {
                    this._gestureManager.removeStageGesture(this._swipeDownGesture);
                    this._swipeDownGesture = null;
                }
                break;
            case GESTURE.SWIPE_UP:
                if (this._swipeUpGesture) {
                    this._gestureManager.removeStageGesture(this._swipeUpGesture);
                    this._swipeUpGesture = null;
                }
                break;
            case GESTURE.PAN:
                if (this._panHorizontalGesture) {
                    this._gestureManager.removeStageGesture(this._panHorizontalGesture);
                    this._panHorizontalGesture = null;
                }
                break;
            default:
                log.warn('removeGesture() passed: ' + gesture + ' which is not supported.');
                return;
        }
    }
    removeAllGestures() {
        this.removeGesture(GESTURE.TAP);
        this.removeGesture(GESTURE.SWIPE_DOWN);
        this.removeGesture(GESTURE.SWIPE_UP);
        this.removeGesture(GESTURE.PAN);
    }
    createRequiredGestures(view) {
        let possibleGestures = [];
        if (!this._tapGesture) {
            possibleGestures.push(GESTURE.TAP);
        }
        if (!this._swipeDownGesture) {
            possibleGestures.push(GESTURE.SWIPE_DOWN);
        }
        let i;
        if (possibleGestures.length > 0 && view) {
            view.findComponent((component) => {
                if (component.hasTouchInteractive) {
                    for (i = possibleGestures.length; i >= 0; i--) {
                        if (component.hasActions(possibleGestures[i])) {
                            this.addGesture(possibleGestures[i]);
                            possibleGestures.splice(i, 1);
                            if (possibleGestures.length === 0) {
                                return true;
                            }
                        }
                    }
                }
                return false;
            });
        }
    }
    destroy() {
        this.removeAllGestures();
        if (this._isSim) {
            this.removeViewportOut();
        }
        else {
            this.removeCoreTouchEvents();
        }
        this._canvas = null;
        this._interactionManager = null;
        this._viewManager = null;
        this._gestureManager = null;
        this._interactionEvent = null;
    }
    addViewportOut() {
        if (this._canvas) {
            this._canvas.addEventListener('mouseleave', this.onViewportOut);
        }
    }
    removeViewportOut() {
        if (this._canvas) {
            this._canvas.removeEventListener('mouseleave', this.onViewportOut);
        }
    }
    onViewportOut() {
        this._gestureManager.stop();
        if (this._panHorizontalGesture) {
            this._panHorizontalGesture.emit({ isFinal: true });
        }
    }
    addCoreTouchEvents() {
        if (this._canvas) {
            this._canvas.addEventListener('mouseleave', this.onCoreTouchEvent);
            this._canvas.addEventListener('mousedown', this.onCoreTouchEvent);
            this._canvas.addEventListener('mouseup', this.onCoreTouchEvent);
            this._canvas.addEventListener('mousemove', this.onCoreTouchEvent);
        }
    }
    removeCoreTouchEvents() {
        if (this._canvas) {
            this._canvas.removeEventListener('mouseleave', this.onCoreTouchEvent);
            this._canvas.removeEventListener('mousedown', this.onCoreTouchEvent);
            this._canvas.removeEventListener('mouseup', this.onCoreTouchEvent);
            this._canvas.removeEventListener('mousemove', this.onCoreTouchEvent);
        }
    }
    onCoreTouchEvent(event) {
        if (event.type === 'mousedown') {
            this._isMouseDown = true;
            this._prevX = this._prevY = null;
        }
        else if (event.type === 'mouseup' || event.type === 'mouseleave') {
            this._prevX = this._prevY = null;
            if (this._isEmulatingPan) {
                this._gestureManager.spoofGestureWithOptions('pan', { isFinal: true, srcEvent: { movementX: 0, movementY: 0 }, pointers: [{ clientX: this._prevX, clientY: this._prevY }] });
            }
            this._isEmulatingPan = false;
            this._isMouseDown = false;
        }
        else if (event.type === 'mousemove') {
            if (!this._isMouseDown) {
                if (!this._isEmulatingPan) {
                    let xMargin = FaceRenderer_1.default.WIDTH * 0.1;
                    if (!this._prevX && !this._prevY && (event.clientX <= xMargin || (event.clientX <= FaceRenderer_1.default.WIDTH && event.clientX >= FaceRenderer_1.default.WIDTH - xMargin))) {
                        this._isEmulatingPan = true;
                        this._prevX = event.clientX;
                        this._prevY = event.clientY;
                    }
                }
                else {
                    this._gestureManager.spoofGestureWithOptions('pan', { isFinal: false, srcEvent: { movementX: (event.clientX - this._prevX),
                            movementY: (event.clientY - this._prevY) }, pointers: [{ clientX: event.clientX, clientY: event.clientY }] });
                    this._prevX = event.clientX;
                    this._prevY = event.clientY;
                }
            }
        }
    }
    resetInput(x, y) {
        this._interactionEvent.data.global.x = x;
        this._interactionEvent.data.global.y = y;
        this._interactionEvent.target = null;
    }
    createTapGesture() {
        if (!this._tapGesture) {
            this._tapGesture = this._gestureManager.addStageGesture(this._gestureManager.hammer.Tap, {
                event: GestureManager_1.default.TAP,
                time: 5000,
                interval: 0,
                threshold: TouchManager.THRESHOLD,
                touchAction: 'manipulation'
            }, this.tapHandler.bind(this));
            return true;
        }
        return false;
    }
    tapHandler(gestureEvent) {
        if (gestureEvent.pointers[0].clientY === 358) {
            log.warn("Ignoring tap event for y coord = 358!");
            return;
        }
        Runtime_1.default.instance.globalEvents.shared.screenGesture.emit(GESTURE.TAP);
        log.info("received tap event", gestureEvent.eventType, gestureEvent.pointers[0].clientX, gestureEvent.pointers[0].clientY);
        let handled = false;
        const currentView = this._viewManager.currentView;
        if (currentView && !currentView.inputLocked) {
            if (currentView.isTouchInteractive && currentView.hasActions(GESTURE.TAP)) {
                handled = currentView.triggerActions(GESTURE.TAP);
            }
            else {
                this.resetInput(gestureEvent.pointers[0].clientX, gestureEvent.pointers[0].clientY);
                if (this.findTappedDisplay(currentView)) {
                    handled = this._elementHit.triggerActions(GESTURE.TAP);
                    this._elementHit = null;
                }
                this.resetInput(0, 0);
            }
        }
        if (handled) {
            Runtime_1.default.instance.face.views.disableMovement = true;
        }
    }
    findTappedDisplay(currentView) {
        this._elementHit = null;
        this._interactionManager['processInteractive'](this._interactionEvent, currentView.stage, this.checkElementHit, true, true);
        return (this._elementHit !== null);
    }
    checkElementHit(event, displayObject, hit) {
        if (hit && displayObject.hasOwnProperty('parentElement')) {
            this._elementHit = displayObject['parentElement'];
        }
    }
    createSwipeDownGesture() {
        if (!this._swipeDownGesture) {
            this._swipeDownGesture = this._gestureManager.addStageGesture(this._gestureManager.hammer.Swipe, {
                event: GestureManager_1.default.SWIPEDOWN,
                direction: this._gestureManager.hammer.DIRECTION_DOWN,
                threshold: TouchManager.THRESHOLD,
                velocity: .3
            }, this.swipeDownHandler.bind(this));
            if (this._panHorizontalGesture) {
                this._panHorizontalGesture.recognizeWith(this._swipeDownGesture);
            }
            return true;
        }
        return false;
    }
    swipeDownHandler(gestureEvent) {
        Runtime_1.default.instance.globalEvents.shared.screenGesture.emit(GESTURE.SWIPE_DOWN);
        const currentView = this._viewManager.currentView;
        if (currentView && currentView.isTouchInteractive) {
            const handled = currentView.triggerActions(GESTURE.SWIPE_DOWN);
            if (handled) {
                Runtime_1.default.instance.face.views.disableMovement = true;
            }
        }
    }
    createSwipeUpGesture() {
        if (!this._swipeUpGesture) {
            this._swipeUpGesture = this._gestureManager.addStageGesture(this._gestureManager.hammer.Swipe, {
                event: GestureManager_1.default.SWIPEUP,
                direction: this._gestureManager.hammer.DIRECTION_UP,
                threshold: TouchManager.THRESHOLD,
                velocity: .3
            }, this.swipeUpHandler.bind(this));
            if (this._panHorizontalGesture) {
                this._panHorizontalGesture.recognizeWith(this._swipeUpGesture);
            }
            if (this._swipeDownGesture) {
                this._swipeDownGesture.recognizeWith(this._swipeUpGesture);
            }
            return true;
        }
        return false;
    }
    swipeUpHandler(gestureEvent) {
        Runtime_1.default.instance.globalEvents.shared.screenGesture.emit(GESTURE.SWIPE_UP);
        const currentView = this._viewManager.currentView;
        if (currentView && currentView.isTouchInteractive) {
            const handled = currentView.triggerActions(GESTURE.SWIPE_UP);
            if (handled) {
                Runtime_1.default.instance.face.views.disableMovement = true;
            }
        }
    }
    createPanHorizontalGesture(gestureEventCallback) {
        if (!this._panHorizontalGesture) {
            if (!this._isSim) {
                this.addCoreTouchEvents();
            }
            this._panHorizontalGesture = this._gestureManager.addStageGesture(this._gestureManager.hammer.Pan, {
                event: GestureManager_1.default.PAN,
                direction: this._gestureManager.hammer.DIRECTION_HORIZONTAL,
                threshold: TouchManager.THRESHOLD,
            }, gestureEventCallback);
            if (this._swipeDownGesture) {
                this._swipeDownGesture.recognizeWith(this._panHorizontalGesture);
            }
            if (this._swipeUpGesture) {
                this._swipeUpGesture.recognizeWith(this._panHorizontalGesture);
            }
            this._gestureManager.addStageGesture(this._gestureManager.hammer.Pan, {
                event: GestureManager_1.default.PAN,
                direction: this._gestureManager.hammer.DIRECTION_HORIZONTAL
            }, () => {
                Runtime_1.default.instance.face.views.disableMovement = true;
            });
            return true;
        }
        else {
            this._gestureManager.addStageGesture(this._gestureManager.hammer.Pan, {
                event: GestureManager_1.default.PAN,
                direction: this._gestureManager.hammer.DIRECTION_HORIZONTAL
            }, gestureEventCallback);
        }
        return false;
    }
}
TouchManager._instance = null;
TouchManager.THRESHOLD = 30;
exports.default = TouchManager;

},{"../../Runtime":1,"../FaceRenderer":99,"../input/GestureManager":160,"./log":149}],126:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_typed_events_1 = require("jibo-typed-events");
const ViewProcess_1 = require("./ViewProcess");
class ViewGlobalEvents extends jibo_typed_events_1.EventContainer {
    constructor() {
        super();
        this.process = new jibo_typed_events_1.Event('View process status changed');
        this.view = new jibo_typed_events_1.Event('View emitted an event');
    }
}
exports.default = ViewGlobalEvents;
class ViewProcessResult {
    constructor(viewProcess) {
        this.status = '';
        this.currentId = '';
        this.closingId = '';
        this.changeOptions = {};
        this.status = viewProcess.status;
        this.currentId = (viewProcess.currentView) ? viewProcess.currentView.id : '';
        this.closingId = (viewProcess.closingView) ? viewProcess.closingView.id : '';
        this.changeOptions = (viewProcess.changeOptions) ? ViewProcess_1.default.serializeOptions(viewProcess.changeOptions) : {};
    }
}
exports.ViewProcessResult = ViewProcessResult;
class ViewResult {
    constructor(view, event, data) {
        this.event = '';
        this.id = '';
        this.type = '';
        this.status = '';
        this.data = null;
        this.event = event;
        this.id = view.id;
        this.type = view.type;
        this.status = view.state;
        this.data = data;
    }
}
exports.ViewResult = ViewResult;

},{"./ViewProcess":128,"jibo-typed-events":undefined}],127:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../../Runtime");
const ComponentCreator_1 = require("./ComponentCreator");
const Component_1 = require("./Component");
const ComponentGroup_1 = require("./ComponentGroup");
const TouchManager_1 = require("./TouchManager");
const ActionData_1 = require("./actions/ActionData");
const View_1 = require("./views/View");
const EyeView_1 = require("./views/EyeView");
const MenuView_1 = require("./views/MenuView");
const ImageView_1 = require("./views/ImageView");
const ContactsView_1 = require("./views/ContactsView");
const TextView_1 = require("./views/TextView");
const Element_1 = require("./components/Element");
const ElementGroup_1 = require("./components/ElementGroup");
const Label_1 = require("./components/Label");
const Button_1 = require("./components/Button");
const StandardButton_1 = require("./components/StandardButton");
const MenuButton_1 = require("./components/MenuButton");
const ContactButton_1 = require("./components/ContactButton");
const List_1 = require("./components/List");
const Clip_1 = require("./components/Clip");
const FaceRenderer_1 = require("../FaceRenderer");
const ViewState_1 = require("./ViewState");
const ContentButton_1 = require("./components/ContentButton");
const ViewProcess_1 = require("./ViewProcess");
const ViewGlobalEvents_1 = require("./ViewGlobalEvents");
const MimManager_1 = require("../../bt/mim/MimManager");
const async = require("async");
const log_1 = require("./log");
const log = log_1.default.createChild('ViewManager');
const DEFAULT_TRANS_TIME = 550;
var STACK_DIRECTION;
(function (STACK_DIRECTION) {
    STACK_DIRECTION[STACK_DIRECTION["ADD"] = 1] = "ADD";
    STACK_DIRECTION[STACK_DIRECTION["REMOVE"] = 2] = "REMOVE";
    STACK_DIRECTION[STACK_DIRECTION["SWAP"] = 3] = "SWAP";
})(STACK_DIRECTION = exports.STACK_DIRECTION || (exports.STACK_DIRECTION = {}));
var TRANSITION;
(function (TRANSITION) {
    TRANSITION["UP"] = "trans_up";
    TRANSITION["DOWN"] = "trans_down";
    TRANSITION["LEFT"] = "trans_left";
    TRANSITION["RIGHT"] = "trans_right";
    TRANSITION["IN"] = "trans_in";
    TRANSITION["OUT"] = "trans_out";
    TRANSITION["EYE"] = "trans_eye";
    TRANSITION["NONE"] = "trans_none";
})(TRANSITION = exports.TRANSITION || (exports.TRANSITION = {}));
class ViewManager {
    constructor(renderer) {
        this.ActionData = ActionData_1.default;
        this.Component = Component_1.default;
        this.ComponentGroup = ComponentGroup_1.default;
        this.Button = Button_1.default;
        this.Clip = Clip_1.default;
        this.ContactButton = ContactButton_1.default;
        this.ContentButton = ContentButton_1.default;
        this.Element = Element_1.default;
        this.Label = Label_1.default;
        this.List = List_1.default;
        this.MenuButton = MenuButton_1.default;
        this.ContactsView = ContactsView_1.default;
        this.EyeView = EyeView_1.default;
        this.MenuView = MenuView_1.default;
        this.ImageView = ImageView_1.default;
        this.View = View_1.default;
        this.TextView = TextView_1.default;
        this.TRANSITION = TRANSITION;
        this.STATE = View_1.STATE;
        this.CATEGORY = View_1.CATEGORY;
        this.STACK_DIRECTION = STACK_DIRECTION;
        this.GESTURE = TouchManager_1.GESTURE;
        this.stage = null;
        this.disabled = false;
        this._disableMovement = false;
        this._viewStates = [];
        this._viewProcess = null;
        this._events = null;
        this._border = null;
        this._waterMark = null;
        this._borderVisibility = false;
        this.stage = new PIXI.Container();
        this._viewStates = [];
        this._viewProcess = new ViewProcess_1.default();
        this._events = new ViewGlobalEvents_1.default();
        this._touchManager = new TouchManager_1.default(renderer, this);
        this._creator = new ComponentCreator_1.default();
        this.registerDefaults();
        this._viewStates.push(this._creator.createViewState(EyeView_1.default.DEFAULT_TYPE));
        const debug = false;
        if (debug) {
            this.logEvents();
        }
    }
    static get TRANS_TIME() {
        return ViewManager._transTime;
    }
    get TRANSITION_TIME() { return ViewManager.TRANS_TIME; }
    get BACK() { return View_1.default.BACK; }
    get EMPTY() { return View_1.default.EMPTY; }
    get PAUSED() { return View_1.default.PAUSED; }
    static get GLOBAL_CACHE() { return 'global-gui'; }
    get currentView() {
        return this._viewProcess.currentView;
    }
    get creator() {
        return this._creator;
    }
    set borderVisible(visible) {
        if (this._borderVisibility !== visible) {
            this._borderVisibility = visible;
            if (this._border) {
                this._border.visible = this._borderVisibility;
            }
        }
    }
    get borderVisible() {
        return this._borderVisibility;
    }
    get viewStackLength() {
        let length = 0;
        if (this._viewStates) {
            length = this._viewStates.length;
        }
        if (this.currentView) {
            length++;
            let pausedParent = this.currentView.pausedParent;
            while (pausedParent) {
                length++;
                pausedParent = pausedParent.pausedParent;
            }
        }
        return length;
    }
    get viewsInProcess() {
        return this._viewProcess.active;
    }
    get events() {
        return this._events;
    }
    set disableMovement(value) {
        if (this._menuMode && value !== this._disableMovement) {
            this._menuMode.release();
            this._menuMode = null;
            const expression = Runtime_1.default.instance.expression;
            if (value) {
                expression.pushAttentionMode(expression.AttentionMode.OFF).then((handle) => {
                    this._menuMode = handle;
                }).catch(() => {
                });
            }
            else {
                expression.pushAttentionMode(expression.AttentionMode.MENU).then((handle) => {
                    this._menuMode = handle;
                }).catch(() => {
                });
            }
        }
        this._disableMovement = value;
    }
    reset() {
        this._viewProcess.reset();
        this._viewProcess = new ViewProcess_1.default();
        this._events.removeAllListeners();
        this._viewStates.length = 0;
        this._viewStates.push(this._creator.createViewState(EyeView_1.default.DEFAULT_TYPE));
        this.removeWatermark();
        this.stage.removeChildren();
        this.borderVisible = false;
        this._touchManager.removeAllGestures();
        if (this._menuMode) {
            this._menuMode.release();
            this._menuMode = null;
        }
    }
    destroyBorder() {
        if (this._border) {
            if (this._border.parent) {
                this._border.parent.removeChild(this._border);
            }
            this._border.destroy({ children: true });
            this._border = null;
        }
    }
    addWatermark(icon) {
        if (!this._border) {
            log.warn('cannot add watermark until border has been created');
            return;
        }
        if (this._waterMark) {
            this.stage.parent.removeChild(this._waterMark);
        }
        this._waterMark = icon;
        this.stage.parent.addChildAt(this._waterMark, this.stage.parent.getChildIndex(this._border) + 1);
    }
    removeWatermark() {
        if (this._waterMark) {
            this.stage.parent.removeChild(this._waterMark);
            this._waterMark = null;
        }
    }
    destroy() {
        this._viewProcess = null;
        this.stage = null;
        this._touchManager.destroy();
        this._touchManager = null;
        Runtime_1.default.instance.loader.deleteCache(ViewManager.GLOBAL_CACHE);
    }
    init(callback, prepWorkers = true) {
        this._touchManager.init();
        this.addViewNextInStack(null, TRANSITION.NONE);
        Runtime_1.default.instance.loader.addCache(ViewManager.GLOBAL_CACHE);
        const sfxMapId = 'guiSfxMap';
        const loader = Runtime_1.default.instance.loader.load({
            id: sfxMapId,
            src: 'core://resources/audio/guiMap.json'
        }, (err) => {
            if (err) {
                log.error('init() error loading initial assets', err);
            }
            this.createBorder(Runtime_1.default.instance.loader.cached('border-corner', ViewManager.GLOBAL_CACHE), Runtime_1.default.instance.loader.cached('border-edge', ViewManager.GLOBAL_CACHE));
            if (callback) {
                callback();
            }
        });
        loader.once('taskDone', (result, original, load) => {
            const assets = [];
            for (let key in result) {
                if (result.hasOwnProperty(key)) {
                    assets.push({
                        id: key,
                        src: result[key],
                        type: 'sound',
                        cache: ViewManager.GLOBAL_CACHE
                    });
                }
            }
            assets.push({
                id: 'border-corner',
                src: 'core://resources/border/border-corner.png',
                type: 'texture',
                cache: ViewManager.GLOBAL_CACHE
            });
            assets.push({
                id: 'border-edge',
                src: 'core://resources/border/border-edge.png',
                type: 'texture',
                cache: ViewManager.GLOBAL_CACHE
            });
            load.addAssets(assets);
        });
        if (prepWorkers) {
            Runtime_1.default.instance.loader.load([
                'core://resources/buttons/images/actionButton_atlas_1.crn',
                'core://resources/buttons/images/skillButton_atlas_1.crn',
                'core://resources/buttons/images/loader_atlas_1.crn'
            ], {
                complete: () => {
                    Runtime_1.default.instance.loader.load([
                        'core://resources/buttons/images/actionButton_atlas_1.crn',
                        'core://resources/buttons/images/skillButton_atlas_1.crn',
                        'core://resources/buttons/images/loader_atlas_1.crn'
                    ], {
                        complete: () => {
                        }
                    });
                }
            });
        }
    }
    createView(viewDeterminer, config, open = false, onOpenComplete, openTransition = TRANSITION.UP, closeTransition = TRANSITION.UP) {
        let viewState = this._creator.createViewState(viewDeterminer, config);
        let view = this._creator.createViewFromState(viewState);
        if (open) {
            this.changeView({ addView: view, transitionOpen: openTransition, transitionClose: closeTransition }, onOpenComplete);
        }
        return view;
    }
    createViewFromConfigPath(configPath, open = false, callback, openTransition = TRANSITION.UP, closeTransition = TRANSITION.UP) {
        if (open) {
            this.changeView({ addView: configPath, transitionOpen: openTransition, transitionClose: closeTransition }, callback);
        }
        else {
            this._creator.createViewFromConfigPath(configPath, callback);
        }
    }
    addViewNextInStack(callback, openTransition = TRANSITION.UP, closeTransition = TRANSITION.UP, onFailure) {
        this.changeView({ addView: this.popViewFromStack(), transitionOpen: openTransition, transitionClose: closeTransition }, callback, onFailure);
    }
    update(elapsed) {
        if (this._viewProcess.currentView) {
            this._viewProcess.currentView.update(elapsed);
        }
    }
    actionHandler(action, fromComponent, onComplete) {
        const data = action.data;
        switch (action.type) {
            case ActionData_1.default.CHANGE_VIEW: {
                if (data && data.hasOwnProperty('options')) {
                    this.changeView(data.options, onComplete);
                }
                else {
                    log.info('actionHandler() action of type: ' + ActionData_1.default.CHANGE_VIEW + ' must specify options');
                }
                break;
            }
            case ActionData_1.default.CLOSE_ALL_OPEN:
                log.warn('Deprecation :: ActionData.CLOSE_ALL_OPEN is deprecated, please use ActionData.CHANGE_VIEW with the appropriate options instead');
                break;
            case ActionData_1.default.OPEN_VIEW: {
                if (data) {
                    let view;
                    let viewConfigPath;
                    if (data.hasOwnProperty('viewType')) {
                        const viewState = new ViewState_1.default(data.viewType);
                        if (data.hasOwnProperty('configPath')) {
                            viewState.configPath = data.configPath;
                        }
                        view = this._creator.createViewFromState(viewState);
                    }
                    else if (data.hasOwnProperty('configPath')) {
                        viewConfigPath = data.configPath;
                    }
                    let openTransition;
                    let closeTransition;
                    if (data.hasOwnProperty('openTransition')) {
                        openTransition = data['openTransition'];
                    }
                    if (data.hasOwnProperty('closeTransition')) {
                        closeTransition = data['closeTransition'];
                    }
                    if (view) {
                        this.changeView({ addView: view, transitionOpen: openTransition, transitionClose: closeTransition }, onComplete);
                    }
                    else if (viewConfigPath) {
                        this.changeView({ addView: viewConfigPath, transitionOpen: openTransition, transitionClose: closeTransition }, onComplete);
                    }
                    else {
                        log.warn('actionHandler() action of type ' + ActionData_1.default.OPEN_VIEW + ' neither View nor path to the View configuration were given, ' +
                            'cannot open a new View without this data');
                    }
                }
                else {
                    log.warn('actionHandler() action of type ' + ActionData_1.default.OPEN_VIEW + ' called but action data was undefined. ' +
                        'Cannot open new view without data defining view to open.');
                }
                break;
            }
            case ActionData_1.default.SWIPE_DOWN: {
                log.warn('Deprecation :: the ActionData.SWIPE_DOWN action is getting phased out');
                this.changeView({ remove: true, transitionClose: TRANSITION.DOWN, transitionOpen: TRANSITION.DOWN }, onComplete);
                break;
            }
            case ActionData_1.default.CLOSE_VIEW: {
                let openTransition = TRANSITION.DOWN;
                let closeTransition = TRANSITION.DOWN;
                if (data) {
                    if (data.hasOwnProperty('openTransition')) {
                        openTransition = data['openTransition'];
                    }
                    if (data.hasOwnProperty('closeTransition')) {
                        closeTransition = data['closeTransition'];
                    }
                }
                this.changeView({ remove: true, transitionClose: closeTransition, transitionOpen: openTransition }, onComplete);
                break;
            }
            case ActionData_1.default.CLOSE_VIEW_EMPTY: {
                log.warn('Deprecation :: ActionData.CLOSE_ALL_OPEN is deprecated, please use ActionData.CLOSE_VIEW_EMPTY with the appropriate options instead');
                let closeTransition = TRANSITION.DOWN;
                if (data) {
                    if (data.hasOwnProperty('closeTransition')) {
                        closeTransition = data['closeTransition'];
                    }
                }
                this.changeView({ remove: true, leaveEmpty: true, transitionClose: closeTransition }, onComplete);
                break;
            }
            case ActionData_1.default.CLOSE_ALL: {
                log.warn('Deprecation :: ActionData.CLOSE_ALL_OPEN is deprecated, please use ActionData.CLOSE_ALL with the appropriate options instead');
                this.changeView({ removeAll: true }, onComplete);
                break;
            }
            case ActionData_1.default.CLOSE_ALL_EMPTY: {
                log.warn('Deprecation :: ActionData.CLOSE_ALL_OPEN is deprecated, please use ActionData.CLOSE_ALL_EMPTY with the appropriate options instead');
                this.changeView({ removeAll: true, leaveEmpty: true }, onComplete);
                break;
            }
            case ActionData_1.default.SWIPE_RIGHT:
            case ActionData_1.default.SWIPE_LEFT: {
                if (this.currentView) {
                    this.currentView.actionEnactor(action);
                }
                break;
            }
            case ActionData_1.default.UTTERANCE: {
                if (data && data.hasOwnProperty('utterance')) {
                    MimManager_1.default.instance.handleSpeech.emit(data.utterance);
                }
                else {
                    log.warn('actionHandler() action ' + ActionData_1.default.UTTERANCE + ' action data was absent ' +
                        ' or utterance string was not specified');
                }
                break;
            }
            case ActionData_1.default.VERBAL_COMMAND: {
                if (data && data.hasOwnProperty('intent')) {
                    this.actionEnactor(action);
                }
                else {
                    log.warn('actionHandler() action ' + ActionData_1.default.VERBAL_COMMAND + ' action called but action data was absent ' +
                        ' or intent string was not specified');
                }
                break;
            }
            case ActionData_1.default.MIM_END: {
                MimManager_1.default.instance.end.emit(data);
                break;
            }
            case ActionData_1.default.MIM_SHOW_GUI: {
                MimManager_1.default.instance.openGUI.emit();
                break;
            }
            default: {
                log.debug('actionHandler() : action type handled: ' + action.type);
                break;
            }
        }
    }
    actionEnactor(action) {
        if (this.currentView) {
            return (this.currentView.actionEnactor(action));
        }
        return false;
    }
    changeView(options, onComplete, onFailure, onLoaded) {
        if (this.disabled) {
            if (onFailure) {
                onFailure("jibo.face.views is disabled.");
            }
            return;
        }
        if (!options) {
            log.warn('changeView() must be provided options, none were given so changeView will not execute.');
            return;
        }
        const process = this._viewProcess;
        this.setTextureGC(false, process.currentView);
        if (process.currentView) {
            process.currentView.lockInput(true);
        }
        if (process.interrupt(options)) {
            this._events.process.emit(new ViewGlobalEvents_1.ViewProcessResult(process));
            process.addProcessToQueue(options, onComplete, onFailure, onLoaded);
        }
        else {
            process.start(onComplete, onFailure, onLoaded, options);
            this._events.process.emit(new ViewGlobalEvents_1.ViewProcessResult(process));
            new Promise((changeResolve, changeReject) => {
                if (process.interrupted) {
                    changeReject(new Error('View process interruption'));
                }
                else {
                    changeResolve();
                }
            })
                .then(() => {
                return new Promise((resolveView, rejectView) => {
                    if (process.interrupted) {
                        rejectView(new Error('View process interruption'));
                    }
                    else {
                        if (!options.leaveEmpty && options.addView) {
                            if (typeof options.addView === 'string') {
                                this._creator.createViewFromConfigPath(options.addView, resolveView, rejectView);
                            }
                            else if (options.addView instanceof View_1.default) {
                                resolveView(options.addView.loadConfig());
                            }
                            else {
                                resolveView(this._creator.createViewFromConfigObject(options.addView));
                            }
                        }
                        else {
                            resolveView(null);
                        }
                    }
                });
            })
                .then((nextView) => {
                if (nextView) {
                    process.storeView(nextView);
                }
                if (process.interrupted) {
                    return Promise.reject(new Error('View process interruption'));
                }
                else {
                    if (options.removeAll) {
                        return this.removeToRoot(process, nextView, options.leaveEmpty, options.transitionClose, options.transitionOpen);
                    }
                    else if (options.removeTo) {
                        return this.removeTo(process, options.removeTo, false, nextView, options.pause, options.leaveEmpty, options.transitionClose, options.transitionOpen);
                    }
                    else if (options.removeToInclude) {
                        return this.removeTo(process, options.removeToInclude, true, nextView, options.pause, options.leaveEmpty, options.transitionClose, options.transitionOpen);
                    }
                    else if (options.remove) {
                        return this.remove(process, nextView, options.leaveEmpty, options.transitionClose, options.transitionOpen);
                    }
                    else if (nextView) {
                        return this.add(process, nextView, options.pause, options.transitionOpen, options.transitionClose);
                    }
                    else {
                        log.warn('changeView() invalid options:', ViewProcess_1.default.serializeOptions(options));
                        return Promise.reject(new Error('View process given invalid options.'));
                    }
                }
            })
                .then((view) => {
                if (process.interrupted) {
                    this.viewProcessFailure(process);
                }
                else {
                    process.complete(view);
                    this.setTextureGC(true, process.currentView);
                    this._events.process.emit(new ViewGlobalEvents_1.ViewProcessResult(this._viewProcess));
                }
            })
                .catch((err) => {
                log.info('changeView() error caught during view changing process:', err);
                this.viewProcessFailure(process);
            });
        }
    }
    addView(viewDeterminer, onAdded, openTransition = TRANSITION.UP, closeTransition = TRANSITION.UP, onFailure) {
        this.changeView({ addView: viewDeterminer, transitionOpen: openTransition, transitionClose: closeTransition }, onAdded, onFailure);
    }
    removeView(onRemoved, openTransition = TRANSITION.DOWN, closeTransition = TRANSITION.DOWN, onFailure) {
        this.changeView({ remove: true, transitionOpen: openTransition, transitionClose: closeTransition }, onRemoved, onFailure);
    }
    forceEyeView(onCompleteCallback, onPressCallback, openTransition = TRANSITION.IN, closeTransition = TRANSITION.UP, onFailure) {
        if (this.disabled) {
            if (onFailure) {
                onFailure("jibo.face.views is disabled.");
            }
            return;
        }
        const process = this._viewProcess;
        let eyeIsCurrent = (this.currentView && this.currentView.type === EyeView_1.default.DEFAULT_TYPE);
        if (eyeIsCurrent && process.status === ViewProcess_1.default.STARTED) {
            eyeIsCurrent = (process.closingView && this.currentView.state === View_1.STATE.LOADED);
        }
        if (eyeIsCurrent) {
            if (process.active) {
                if (onPressCallback) {
                    this.currentView.addAction(ActionData_1.default.CALLBACK, { callback: onPressCallback }, true);
                }
                if (process.onComplete) {
                    const origComplete = process.onComplete;
                    process.onComplete = (view) => {
                        this.clearViewStack(view);
                        origComplete(view);
                        this.closePaused(process, view, TRANSITION.NONE)
                            .then(() => {
                            if (onCompleteCallback) {
                                onCompleteCallback(view);
                            }
                        })
                            .catch((err) => {
                            log.error('forceEyeView() error closing paused views', view);
                            if (onFailure) {
                                onFailure();
                            }
                        });
                    };
                }
                else {
                    process.onComplete = (view) => {
                        this.clearViewStack(view);
                        this.closePaused(process, view, TRANSITION.NONE)
                            .then(() => {
                            if (onCompleteCallback) {
                                onCompleteCallback(view);
                            }
                        })
                            .catch((err) => {
                            log.error('forceEyeView() error closing paused views', view);
                            if (onFailure) {
                                onFailure();
                            }
                        });
                    };
                }
                if (onFailure) {
                    if (process.onFailure) {
                        const origFailure = process.onFailure;
                        process.onFailure = () => {
                            origFailure();
                            onFailure();
                        };
                    }
                    else {
                        process.onFailure = onFailure;
                    }
                }
            }
            else {
                this.clearViewStack(this.currentView);
                this.closePaused(process, this.currentView, TRANSITION.NONE)
                    .then(() => {
                    this.setTextureGC(true, process.currentView);
                    if (onPressCallback) {
                        this.currentView.lockInput(false);
                        this.currentView.addAction(ActionData_1.default.CALLBACK, { callback: onPressCallback }, true);
                    }
                    if (onCompleteCallback) {
                        onCompleteCallback(this.currentView);
                    }
                })
                    .catch((err) => {
                    log.error('forceEyeView() error closing paused views', this.currentView);
                    if (onFailure) {
                        onFailure();
                    }
                });
            }
        }
        else {
            this.changeView({
                removeAll: true,
                transitionOpen: openTransition,
                transitionClose: closeTransition,
            }, (view) => {
                if (view) {
                    if (onPressCallback) {
                        view.addAction(ActionData_1.default.CALLBACK, { callback: onPressCallback }, true);
                    }
                }
                else {
                    log.warn('forceEyeView() view was not returned from view change process removeAll, this should not happen.');
                }
                if (onCompleteCallback) {
                    onCompleteCallback(view);
                }
            }, onFailure);
        }
    }
    viewStackCleanup(closeTransition = TRANSITION.DOWN) {
        return new Promise((resolve, reject) => {
            let view = this.currentView;
            if (view) {
                if (view.category !== View_1.CATEGORY.EYE) {
                    this.changeView({
                        removeAll: true,
                        leaveEmpty: true,
                        transitionClose: closeTransition
                    }, () => {
                        resolve();
                    }, () => {
                        log.error('cleanupViews() failed to remove all views, calling done anyway');
                        reject();
                    });
                }
                else {
                    this.forceEyeView(() => {
                        resolve();
                    }, null, TRANSITION.IN, TRANSITION.DOWN, () => {
                        log.error('cleanupViews() failure during forceEyeView, calling done anyway');
                        reject();
                    });
                }
            }
            else {
                this.changeView({
                    removeAll: true,
                    leaveEmpty: true
                }, () => {
                    resolve();
                }, () => {
                    log.error('cleanupViews() failed to remove all views, calling done anyway');
                    reject();
                });
            }
        });
    }
    hasView(id) {
        let view = this._viewProcess.currentView;
        while (view) {
            if (view.id === id) {
                return true;
            }
            else {
                view = view.pausedParent;
            }
        }
        for (let i = this._viewStates.length - 1; i >= 0; i--) {
            if (this._viewStates[i].id === id) {
                return true;
            }
        }
        return false;
    }
    resetTransTime(transTime = DEFAULT_TRANS_TIME) {
        ViewManager._transTime = transTime;
    }
    viewProcessFailure(process) {
        let leaveCurrent = false;
        let queueLength = process.processQueue.length;
        if (process.interrupted && queueLength > 0) {
            let currentView = process.currentView;
            if (currentView) {
                let nextOptions = process.processQueue[queueLength - 1].changeOptions;
                let currentOptions = process.changeOptions;
                if (nextOptions.remove || nextOptions.removeAll || (nextOptions.removeToInclude && nextOptions.removeToInclude === currentView.id)) {
                    if (currentOptions.removeTo || currentOptions.removeAll) {
                        log.info('viewProcessFailure() managing clean transition with removeTo or removeToInclude in current process is too complicated, will not attempt');
                    }
                    else {
                        if (currentView.state === View_1.STATE.LOADED || currentView.state === View_1.STATE.OPENED) {
                            log.info('viewProcessFailure() since interrupting process will close current view ' + currentView.id + ', preserve it so it can be closed cleanly: ');
                            leaveCurrent = true;
                            if (process.closingView && process.closingView.state !== View_1.STATE.DESTROYED) {
                                if (currentOptions.addView && !currentOptions.pause && !currentOptions.remove && !currentOptions.removeAll) {
                                    log.debug('viewProcessFailure() add closing view and its paused views to stack.');
                                    this.pushViewWithPausedToStack(process.closingView);
                                }
                            }
                        }
                    }
                }
            }
        }
        process.fail(leaveCurrent);
        this._events.process.emit(new ViewGlobalEvents_1.ViewProcessResult(process));
        if (!process.currentView && this.viewStackLength === 0) {
            this._viewStates.push(this._creator.createViewState(EyeView_1.default.DEFAULT_TYPE));
        }
        log.debug('viewProcessFailure() number of processes in queue: ' + process.processQueue.length);
        if (queueLength > 0) {
            let queuedProcess = null;
            let whileCondition = true;
            while (whileCondition) {
                queuedProcess = process.processQueue.shift();
                if (process.processQueue.length === 0) {
                    log.debug('viewProcessFailure() start process at top of queue', ViewProcess_1.default.serializeOptions(queuedProcess.changeOptions));
                    Runtime_1.default.instance.face.paused = false;
                    this.changeView(queuedProcess.changeOptions, queuedProcess.onComplete, queuedProcess.onFailure, queuedProcess.onLoaded);
                    return;
                }
                else {
                    log.debug('viewProcessFailure() process beneath top most process, trigger fail', ViewProcess_1.default.serializeOptions(queuedProcess.changeOptions));
                    queuedProcess.fail();
                    this._events.process.emit(new ViewGlobalEvents_1.ViewProcessResult(queuedProcess));
                }
            }
        }
        else if (process.currentView) {
            process.currentView.lockInput(false);
            Runtime_1.default.instance.face.paused = false;
            log.info('viewProcessFailure() view process failed with no pending processes in queue, resume use of current view');
            this.setTextureGC(true, process.currentView);
        }
    }
    add(process, nextView, pauseOptions, openTransition = TRANSITION.UP, closeTransition = TRANSITION.UP) {
        return new Promise((resolve, reject) => {
            if (process.currentView) {
                if (nextView.willPauseParent || pauseOptions) {
                    nextView.pausedParent = process.currentView;
                    process.currentView = nextView;
                    nextView.applyTransitions(View_1.default.PAUSED, true, STACK_DIRECTION.ADD);
                    resolve(this.pauseThenOpen(process, nextView, nextView.pausedParent, pauseOptions, openTransition));
                }
                else {
                    process.closingView = process.currentView;
                    process.currentView = nextView;
                    process.storeView(process.closingView);
                    this.prepareTransitions(nextView, process.closingView, STACK_DIRECTION.ADD);
                    resolve(this.closeAndOpenViews(process, nextView, process.closingView, openTransition, closeTransition, true));
                }
            }
            else {
                process.currentView = nextView;
                nextView.applyTransitions(View_1.default.EMPTY, true, STACK_DIRECTION.ADD);
                resolve(this.openView(process, nextView, openTransition));
            }
        });
    }
    remove(process, nextView, leaveEmpty = false, closeTransition = TRANSITION.DOWN, openTransition = TRANSITION.DOWN) {
        return new Promise((resolve, reject) => {
            if (process.currentView) {
                if (this.viewStackLength === 1) {
                    if (leaveEmpty) {
                        process.closingView = process.currentView;
                        process.currentView = null;
                        process.storeView(process.closingView);
                        process.closingView.applyTransitions(View_1.default.EMPTY, false, STACK_DIRECTION.REMOVE);
                        resolve(this.closeView(process, process.closingView, closeTransition, true));
                    }
                    else if (nextView) {
                        process.closingView = process.currentView;
                        process.currentView = nextView;
                        process.storeView(process.closingView);
                        this.prepareTransitions(nextView, process.closingView, STACK_DIRECTION.SWAP);
                        resolve(this.closeAndOpenViews(process, nextView, process.closingView, openTransition, closeTransition, true));
                    }
                    else {
                        resolve(process.currentView);
                    }
                }
                else {
                    if (leaveEmpty) {
                        process.closingView = process.currentView;
                        process.currentView = null;
                        process.storeView(process.closingView);
                        process.closingView.applyTransitions(View_1.default.EMPTY, false, STACK_DIRECTION.REMOVE);
                        resolve(this.closeView(process, process.closingView, closeTransition));
                    }
                    else if (nextView) {
                        nextView.pausedParent = process.currentView.pausedParent;
                        process.closingView = process.currentView;
                        process.currentView = nextView;
                        process.storeView(process.closingView);
                        this.prepareTransitions(nextView, process.closingView, STACK_DIRECTION.SWAP);
                        resolve(this.closeAndOpenViews(process, nextView, process.closingView, openTransition, closeTransition, false));
                    }
                    else {
                        if (process.currentView.pausedParent) {
                            process.closingView = process.currentView;
                            process.currentView = nextView = process.currentView.pausedParent;
                            process.storeView(process.closingView);
                            process.storeView(nextView);
                            process.closingView.applyTransitions(View_1.default.PAUSED, false, STACK_DIRECTION.REMOVE);
                            resolve(this.closeView(process, process.closingView, closeTransition, false, false)
                                .then(() => {
                                process.closingView.destroy();
                                Runtime_1.default.instance.face.paused = false;
                                this.updateAttentionMode(nextView);
                                nextView.pause(false);
                                return nextView;
                            }));
                        }
                        else {
                            process.closingView = process.currentView;
                            process.currentView = nextView = this.popViewFromStack();
                            process.storeView(process.closingView);
                            process.storeView(nextView);
                            this.prepareTransitions(nextView, process.closingView, STACK_DIRECTION.REMOVE);
                            resolve(this.closeAndOpenViews(process, nextView, process.closingView, openTransition, closeTransition, false));
                        }
                    }
                }
            }
            else {
                if (leaveEmpty) {
                    resolve(null);
                }
                else if (nextView) {
                    process.currentView = nextView;
                    process.storeView(nextView);
                    nextView.applyTransitions(View_1.default.EMPTY, true, STACK_DIRECTION.ADD);
                    resolve(this.openView(process, nextView, openTransition));
                }
                else {
                    process.currentView = nextView = this.popViewFromStack();
                    process.storeView(nextView);
                    nextView.applyTransitions(View_1.default.EMPTY, true, STACK_DIRECTION.REMOVE);
                    resolve(this.openView(process, nextView, openTransition));
                }
            }
        });
    }
    removeToRoot(process, nextView, leaveEmpty = false, closeTransition = TRANSITION.DOWN, openTransition = TRANSITION.DOWN) {
        return new Promise((resolve, reject) => {
            if (process.currentView) {
                if (this.viewStackLength === 1) {
                    if (leaveEmpty) {
                        process.closingView = process.currentView;
                        process.currentView = null;
                        process.storeView(process.closingView);
                        process.closingView.applyTransitions(View_1.default.EMPTY, false, STACK_DIRECTION.REMOVE);
                        resolve(this.closeView(process, process.closingView, closeTransition, true));
                    }
                    else if (nextView) {
                        process.closingView = process.currentView;
                        process.currentView = nextView;
                        process.storeView(process.closingView);
                        this.prepareTransitions(nextView, process.closingView, STACK_DIRECTION.ADD);
                        resolve(this.closeAndOpenViews(process, nextView, process.closingView, openTransition, closeTransition, true));
                    }
                    else {
                        resolve(process.currentView);
                    }
                }
                else {
                    if (leaveEmpty) {
                        process.closingView = process.currentView;
                        process.currentView = null;
                        process.storeView(process.closingView);
                        resolve(this.closeViewWithPaused(process, process.closingView, closeTransition)
                            .then(() => {
                            this.clearViewStack(null);
                            return (null);
                        }));
                    }
                    else if (nextView) {
                        process.closingView = process.currentView;
                        process.currentView = nextView;
                        process.storeView(process.closingView);
                        this.clearViewStack(null);
                        resolve(this.closeWithPausedAndOpenViews(process, nextView, process.closingView, openTransition, closeTransition, false, STACK_DIRECTION.SWAP));
                    }
                    else {
                        process.closingView = process.currentView;
                        process.storeView(process.closingView);
                        this.clearViewStack(null);
                        process.currentView = nextView = this.popViewFromStack();
                        process.storeView(nextView);
                        resolve(this.closeWithPausedAndOpenViews(process, nextView, process.closingView, openTransition, closeTransition, false, STACK_DIRECTION.REMOVE));
                    }
                }
            }
            else {
                if (leaveEmpty) {
                    this.clearViewStack(null);
                    resolve(null);
                }
                else if (nextView) {
                    process.currentView = nextView;
                    this.clearViewStack(null);
                    resolve(this.openView(process, nextView, openTransition));
                }
                else {
                    this.clearViewStack(null);
                    process.currentView = nextView = this.popViewFromStack();
                    process.storeView(nextView);
                    resolve(this.openView(process, nextView, openTransition));
                }
            }
        });
    }
    removeTo(process, viewId, includeId = false, nextView, pauseOptions, leaveEmpty = false, closeTransition = TRANSITION.DOWN, openTransition = TRANSITION.DOWN) {
        return new Promise((resolve, reject) => {
            if (process.currentView) {
                if (process.currentView.id === viewId) {
                    if (includeId) {
                        resolve(this.remove(process, nextView, leaveEmpty, closeTransition, openTransition));
                    }
                    else {
                        if (nextView) {
                            resolve(this.add(process, nextView, pauseOptions, openTransition));
                        }
                        else {
                            resolve(process.currentView);
                        }
                    }
                }
                else {
                    let found = false;
                    let index = 0;
                    let pausedParent = process.currentView.pausedParent;
                    while (pausedParent) {
                        index++;
                        if (pausedParent.id === viewId) {
                            found = true;
                            break;
                        }
                        pausedParent = pausedParent.pausedParent;
                    }
                    if (found) {
                        if (includeId) {
                            index++;
                        }
                        let closingViews = [];
                        let pausedView = process.currentView;
                        while (index > 0 && pausedView) {
                            closingViews.unshift(pausedView);
                            pausedView.applyTransitions(View_1.default.PAUSED, false, STACK_DIRECTION.REMOVE);
                            index--;
                            if (pausedView.pausedParent) {
                                pausedView = pausedView.pausedParent;
                            }
                            else {
                                break;
                            }
                        }
                        process.closingView = process.currentView;
                        process.storeView(process.closingView);
                        if (!nextView) {
                            process.currentView = pausedView;
                            process.storeView(pausedView);
                        }
                        this.closeGroup(process, closingViews, closeTransition, false, false)
                            .then(() => {
                            if (leaveEmpty) {
                                if (pausedView) {
                                    for (let i = closingViews.length - 1; i >= 0; i--) {
                                        closingViews[i].destroy();
                                    }
                                    Runtime_1.default.instance.face.paused = false;
                                    this.updateAttentionMode(pausedView);
                                    pausedView.pause(false);
                                }
                                else {
                                    for (let i = closingViews.length - 1; i >= 0; i--) {
                                        closingViews[i].destroy();
                                    }
                                }
                                resolve(pausedView);
                            }
                            else if (nextView) {
                                for (let i = closingViews.length - 1; i >= 0; i--) {
                                    closingViews[i].destroy();
                                }
                                nextView.pausedParent = pausedView;
                                nextView.applyTransitions(View_1.default.PAUSED, true, STACK_DIRECTION.SWAP);
                                resolve(this.openView(process, nextView, openTransition));
                            }
                            else {
                                if (pausedView) {
                                    for (let i = closingViews.length - 1; i >= 0; i--) {
                                        closingViews[i].destroy();
                                    }
                                    Runtime_1.default.instance.face.paused = false;
                                    this.updateAttentionMode(pausedView);
                                    pausedView.pause(false);
                                    resolve(pausedView);
                                }
                                else {
                                    for (let i = closingViews.length - 1; i >= 0; i--) {
                                        closingViews[i].destroy();
                                    }
                                    throw (new Error('Error removing to paused view'));
                                }
                            }
                        });
                    }
                    else {
                        index = 0;
                        for (let i = this._viewStates.length - 1; i >= 0; i--) {
                            if (this._viewStates[i].id === viewId) {
                                found = true;
                                break;
                            }
                            index++;
                        }
                        if (found) {
                            if (includeId) {
                                index++;
                            }
                            while (index > 0) {
                                this.popViewFromStack();
                                index--;
                            }
                            process.closingView = process.currentView;
                            process.storeView(process.closingView);
                            if (!leaveEmpty) {
                                if (!nextView) {
                                    nextView = this.popViewFromStack();
                                    process.storeView(nextView);
                                }
                                process.currentView = nextView;
                            }
                            if (leaveEmpty) {
                                resolve(this.closeViewWithPaused(process, process.closingView, closeTransition));
                            }
                            else {
                                resolve(this.closeWithPausedAndOpenViews(process, nextView, process.closingView, openTransition, closeTransition, false, STACK_DIRECTION.REMOVE));
                            }
                        }
                        else {
                            reject(new Error('Corresponding view not found for id:' + viewId));
                        }
                    }
                }
            }
            else {
                let stackFound = false;
                let stackIndex = 0;
                for (let i = this._viewStates.length - 1; i >= 0; i--) {
                    stackIndex++;
                    if (this._viewStates[i].id === viewId) {
                        stackFound = true;
                        break;
                    }
                }
                if (stackFound) {
                    if (includeId) {
                        stackIndex++;
                    }
                    for (let i = 0; i < stackIndex; i++) {
                        this._viewStates.pop();
                    }
                    if (leaveEmpty) {
                        resolve(null);
                    }
                    else {
                        if (!nextView) {
                            nextView = this.popViewFromStack();
                        }
                        resolve(this.add(process, nextView, null, openTransition, closeTransition));
                    }
                }
                else {
                    reject(new Error('Corresponding view not found for id:' + viewId));
                }
            }
        });
    }
    openView(process, view, openTransition) {
        return new Promise((resolve, reject) => {
            view.once(View_1.STATE.LOAD_ERROR, () => {
                reject(new Error('View load error'));
            });
            view.once(View_1.STATE.DATA_LOADED, () => {
                if (process.interrupted) {
                    return reject(new Error('View process interruption'));
                }
                view.once(View_1.STATE.LOADED, () => {
                    if (process.interrupted) {
                        return reject(new Error('View process interruption'));
                    }
                    view.removeAllListeners(View_1.STATE.LOAD_ERROR);
                    const proceed = () => {
                        if (process.interrupted) {
                            return reject(new Error('View process interruption'));
                        }
                        view.once(View_1.STATE.OPENED, (openedView) => {
                            if (process.interrupted) {
                                return reject(new Error('View process interruption'));
                            }
                            openedView.pause(false);
                            resolve(openedView);
                        });
                        Runtime_1.default.instance.face.paused = false;
                        this.stage.addChild(view.stage);
                        this.updateAttentionMode(view);
                        view.open(null, openTransition);
                    };
                    if (process.onLoaded) {
                        if (process.onLoaded.length > 1) {
                            process.onLoaded(view, proceed);
                        }
                        else {
                            process.onLoaded(view);
                            proceed();
                        }
                    }
                    else {
                        proceed();
                    }
                });
                view.loadAssets();
            });
            view.init(this, false);
        });
    }
    closeView(process, view, closeTransition, addToStack = false, destroyView = true, toPaused = false) {
        return new Promise((resolve, reject) => {
            if (!view.inputLocked) {
                view.lockInput(true);
            }
            view.once(View_1.STATE.CLOSED, (closedView) => {
                if (process.interrupted) {
                    return reject(new Error('View process interruption'));
                }
                if (addToStack) {
                    this.pushViewToStack(view);
                }
                Runtime_1.default.instance.face.paused = true;
                if (destroyView) {
                    closedView.destroy();
                }
                resolve(null);
            });
            view.close(null, closeTransition);
        });
    }
    closeAndOpenViews(process, nextView, closeView, openTransition, closeTransition, addToStack = false) {
        return new Promise((resolve, reject) => {
            let interrupted = false;
            let proceedCount = 2;
            const proceed = () => {
                if (process.interrupted) {
                    if (!interrupted) {
                        interrupted = true;
                        reject(new Error('View process interruption'));
                    }
                    return;
                }
                proceedCount--;
                if (proceedCount === 0) {
                    if (!this.checkViewsValid([closeView, nextView])) {
                        if (!interrupted) {
                            interrupted = true;
                            reject(new Error('View process involves invalid views'));
                        }
                        return;
                    }
                    closeView.destroyAll();
                    nextView.once(View_1.STATE.OPENED, () => {
                        if (process.interrupted) {
                            if (!interrupted) {
                                interrupted = true;
                                reject(new Error('View process interruption'));
                            }
                            return;
                        }
                        nextView.pause(false);
                        resolve(nextView);
                    });
                    Runtime_1.default.instance.face.paused = false;
                    this.stage.addChild(nextView.stage);
                    this.updateAttentionMode(nextView);
                    nextView.open(null, openTransition);
                }
            };
            closeView.once(View_1.STATE.CLOSED, (closedView) => {
                if (process.interrupted) {
                    if (!interrupted) {
                        interrupted = true;
                        reject(new Error('View process interruption'));
                    }
                    return;
                }
                if (addToStack) {
                    this.pushViewWithPausedToStack(closedView);
                }
                Runtime_1.default.instance.face.paused = true;
                proceed();
            });
            closeView.close(null, closeTransition);
            nextView.once(View_1.STATE.LOAD_ERROR, () => {
                if (!interrupted) {
                    interrupted = true;
                    reject(new Error('View load error'));
                }
                return;
            });
            nextView.once(View_1.STATE.DATA_LOADED, () => {
                if (process.interrupted) {
                    if (!interrupted) {
                        interrupted = true;
                        reject(new Error('View process interruption'));
                    }
                    return;
                }
                nextView.once(View_1.STATE.LOADED, () => {
                    if (process.interrupted) {
                        if (!interrupted) {
                            interrupted = true;
                            reject(new Error('View process interruption'));
                        }
                        return;
                    }
                    nextView.removeAllListeners(View_1.STATE.LOAD_ERROR);
                    if (process.onLoaded) {
                        if (process.onLoaded.length > 1) {
                            process.onLoaded(nextView, proceed);
                        }
                        else {
                            process.onLoaded(nextView);
                            proceed();
                        }
                    }
                    else {
                        proceed();
                    }
                });
                nextView.loadAssets();
            });
            nextView.init(this, false);
        });
    }
    closeWithPausedAndOpenViews(process, nextView, closeView, openTransition, closeTransition, addToStack = false, stackDirection) {
        return new Promise((resolve, reject) => {
            let interrupted = false;
            let closingViews = [];
            while (closeView) {
                closingViews.unshift(closeView);
                if (closeView.pausedParent) {
                    closeView.applyTransitions(View_1.default.PAUSED, false, stackDirection);
                    closeView = closeView.pausedParent;
                }
                else {
                    break;
                }
            }
            if (closingViews.length > 1) {
                closeView.applyTransitions(View_1.default.PAUSED, false, stackDirection);
                nextView.applyTransitions(View_1.default.PAUSED, true, stackDirection);
            }
            else {
                closeView.applyTransitions(nextView, false, stackDirection);
                nextView.applyTransitions(closeView, true, stackDirection);
            }
            let proceedCount = 2;
            const proceed = () => {
                if (process.interrupted) {
                    if (!interrupted) {
                        interrupted = true;
                        reject(new Error('View process interruption'));
                    }
                    return;
                }
                proceedCount--;
                if (proceedCount === 0) {
                    if (!this.checkViewsValid(closingViews) || !this.checkViewsValid(nextView)) {
                        if (!interrupted) {
                            interrupted = true;
                            reject(new Error('View process involves invalid views'));
                        }
                        return;
                    }
                    for (let i = 0; i < closingViews.length; i++) {
                        closingViews[i].destroy();
                    }
                    nextView.once(View_1.STATE.OPENED, (nextView) => {
                        if (process.interrupted) {
                            if (!interrupted) {
                                interrupted = true;
                                reject(new Error('View process interruption'));
                            }
                            return;
                        }
                        nextView.pause(false);
                        resolve(nextView);
                    });
                    Runtime_1.default.instance.face.paused = false;
                    this.stage.addChild(nextView.stage);
                    this.updateAttentionMode(nextView);
                    nextView.open(null, openTransition);
                }
            };
            this.closeGroup(process, closingViews, closeTransition, addToStack, false)
                .then(() => {
                proceed();
            })
                .catch(() => {
                if (!interrupted) {
                    interrupted = true;
                    reject(new Error('View load error'));
                }
            });
            nextView.once(View_1.STATE.LOAD_ERROR, () => {
                if (!interrupted) {
                    interrupted = true;
                    reject(new Error('View load error'));
                }
            });
            nextView.once(View_1.STATE.DATA_LOADED, () => {
                if (process.interrupted) {
                    if (!interrupted) {
                        interrupted = true;
                        reject(new Error('View process interruption'));
                    }
                    return;
                }
                nextView.once(View_1.STATE.LOADED, () => {
                    if (process.interrupted) {
                        if (!interrupted) {
                            interrupted = true;
                            reject(new Error('View process interruption'));
                        }
                        return;
                    }
                    nextView.removeAllListeners(View_1.STATE.LOAD_ERROR);
                    if (process.onLoaded) {
                        if (process.onLoaded.length > 1) {
                            process.onLoaded(nextView, proceed);
                        }
                        else {
                            process.onLoaded(nextView);
                            proceed();
                        }
                    }
                    else {
                        proceed();
                    }
                });
                nextView.loadAssets();
            });
            nextView.init(this, false);
        });
    }
    closePaused(process, view, closeTransition, addToStack = false, destroyViews = true) {
        return new Promise((resolve, reject) => {
            if (view.pausedParent) {
                this.closeViewWithPaused(process, view.pausedParent, closeTransition, addToStack, destroyViews)
                    .then(() => {
                    view.pausedParent = null;
                    Runtime_1.default.instance.face.paused = false;
                    resolve();
                })
                    .catch((err) => {
                    reject(err);
                });
            }
            else {
                resolve();
            }
        });
    }
    closeViewWithPaused(process, view, closeTransition, addToStack = false, destroyViews = true) {
        let closingViews = [];
        while (view) {
            closingViews.unshift(view);
            view.applyTransitions(View_1.default.PAUSED, false, STACK_DIRECTION.REMOVE);
            view = view.pausedParent;
        }
        return this.closeGroup(process, closingViews, closeTransition, addToStack, destroyViews);
    }
    closeGroup(process, closingViews, closeTransition, addToStack = false, destroyViews = true) {
        return new Promise((resolve, reject) => {
            let closeTransitions = [];
            for (let i = 0; i < closingViews.length; i++) {
                closeTransitions.push(function (subCallback) {
                    closingViews[i].close(subCallback, closeTransition);
                });
            }
            async.parallel(closeTransitions, function (err, results) {
                closeTransitions = null;
                if (process.interrupted) {
                    return reject(new Error('View process interruption'));
                }
                if (err) {
                    log.warn('closeAllPaused() issue during transition: error: ', err);
                    closingViews = null;
                    return reject(new Error('Async view close error'));
                }
                Runtime_1.default.instance.face.paused = true;
                for (let i = 0; i < closingViews.length; i++) {
                    if (addToStack) {
                        this.pushViewToStack(closingViews[i]);
                    }
                    if (destroyViews) {
                        closingViews[i].destroy();
                    }
                }
                closingViews = null;
                resolve(null);
            }.bind(this));
        });
    }
    pauseThenOpen(process, nextView, pausingView, pauseOptions, openTransition) {
        return new Promise((resolve, reject) => {
            nextView.once(View_1.STATE.LOAD_ERROR, () => {
                reject(new Error('View load error'));
            });
            pausingView.lockInput(true);
            nextView.pausedParent = pausingView;
            nextView.once(View_1.STATE.DATA_LOADED, () => {
                if (process.interrupted) {
                    return reject(new Error('View process interruption'));
                }
                nextView.once(View_1.STATE.LOADED, () => {
                    if (process.interrupted) {
                        return reject(new Error('View process interruption'));
                    }
                    nextView.removeAllListeners(View_1.STATE.LOAD_ERROR);
                    const proceed = () => {
                        nextView.once(View_1.STATE.OPENED, (nextView) => {
                            if (process.interrupted) {
                                return reject(new Error('View process interruption'));
                            }
                            nextView.pause(false);
                            resolve(nextView);
                        });
                        Runtime_1.default.instance.face.paused = false;
                        pausingView.pause(true, (pauseOptions || nextView.pauseOptions));
                        this.stage.addChild(nextView.stage);
                        this.updateAttentionMode(nextView);
                        nextView.open(null, openTransition);
                    };
                    if (process.onLoaded) {
                        if (process.onLoaded.length > 1) {
                            process.onLoaded(nextView, proceed);
                        }
                        else {
                            process.onLoaded(nextView);
                            proceed();
                        }
                    }
                    else {
                        proceed();
                    }
                });
                nextView.loadAssets();
            });
            nextView.init(this, false);
        });
    }
    prepareTransitions(openingView, closingView, stackDirection) {
        if (openingView) {
            openingView.applyTransitions(closingView, true, stackDirection);
        }
        if (closingView) {
            closingView.applyTransitions(openingView, false, stackDirection);
        }
    }
    popViewFromStack() {
        if (this._viewStates.length > 0) {
            const state = this._viewStates.pop();
            return this._creator.createViewFromState(state);
        }
        else {
            log.warn('popViewFromStack() stack is empty, creating an eye by default, not ideal.');
            return this.createView(EyeView_1.default.DEFAULT_TYPE);
        }
    }
    pushViewToStack(view) {
        if (!view.viewStateStacked && (view.state === View_1.STATE.LOADED || view.state === View_1.STATE.OPENED || view.state === View_1.STATE.CLOSED)) {
            const state = view.createState();
            view.viewStateStacked = true;
            this._viewStates.push(state);
        }
        else {
            log.warn('pushViewToStack() View not ready to be added to stack beause state is: ' + view.state);
        }
    }
    pushViewWithPausedToStack(view) {
        if (view.pausedParent) {
            const closingViews = [];
            let pausedView = view.pausedParent;
            while (pausedView) {
                closingViews.unshift(pausedView);
                pausedView = pausedView.pausedParent;
            }
            for (let i = 0; i < closingViews.length; i++) {
                this.pushViewToStack(closingViews[i]);
            }
        }
        this.pushViewToStack(view);
    }
    clearViewStack(currentView) {
        if (this._viewStates.length === 0 && !currentView) {
            this._viewStates.push(this._creator.createViewState(EyeView_1.default.DEFAULT_TYPE));
        }
        if (this._viewStates.length > 0) {
            this._viewStates.length = (currentView && currentView.type === EyeView_1.default.DEFAULT_TYPE) ? 0 : 1;
        }
    }
    updateAttentionMode(view) {
        if (view && view.category === View_1.CATEGORY.GUI) {
            if (this._menuMode) {
                this._menuMode.release();
                this._menuMode = null;
            }
            const expression = Runtime_1.default.instance.expression;
            let mode = expression.AttentionMode.MENU;
            if (this._disableMovement) {
                mode = expression.AttentionMode.OFF;
            }
            expression.pushAttentionMode(mode).then((handle) => {
                this._menuMode = handle;
            }).catch(() => {
            });
        }
        else if (this._menuMode) {
            this._menuMode.release();
            this._menuMode = null;
            if (view && view.category !== View_1.CATEGORY.GUI) {
                this._disableMovement = false;
            }
        }
    }
    setTextureGC(autoOn, currentView) {
        if (autoOn) {
            if ((this.viewStackLength === 1) && (currentView && currentView.category === View_1.CATEGORY.EYE)) {
                Runtime_1.default.instance.face.textureGC.mode = PIXI.GC_MODES.AUTO;
                return;
            }
        }
        Runtime_1.default.instance.face.textureGC.mode = PIXI.GC_MODES.MANUAL;
    }
    createBorder(cornerTexture, edgeTexture) {
        const border = new PIXI.Container();
        this.stage.parent.addChildAt(border, this.stage.parent.getChildIndex(this.stage) + 1);
        let corner = new PIXI.Sprite(cornerTexture);
        border.addChild(corner);
        corner = new PIXI.Sprite(cornerTexture);
        corner.scale.x = -1;
        corner.x = FaceRenderer_1.default.WIDTH;
        border.addChild(corner);
        corner = new PIXI.Sprite(cornerTexture);
        corner.scale.y = -1;
        corner.y = FaceRenderer_1.default.HEIGHT;
        border.addChild(corner);
        corner = new PIXI.Sprite(cornerTexture);
        corner.scale.x = -1;
        corner.scale.y = -1;
        corner.x = FaceRenderer_1.default.WIDTH;
        corner.y = FaceRenderer_1.default.HEIGHT;
        border.addChild(corner);
        const cornerW = corner.width;
        const edgeW = FaceRenderer_1.default.WIDTH - cornerW * 2;
        const edgeH = FaceRenderer_1.default.HEIGHT - cornerW * 2;
        let edge = new PIXI.Sprite(edgeTexture);
        edge.height = edgeH;
        edge.y = cornerW;
        border.addChild(edge);
        edge = new PIXI.Sprite(edgeTexture);
        edge.height = edgeH;
        edge.scale.x = -1;
        edge.x = FaceRenderer_1.default.WIDTH;
        edge.y = cornerW;
        border.addChild(edge);
        edge = new PIXI.Sprite(edgeTexture);
        edge.scale.y = -1;
        edge.rotation = Math.PI / 2;
        edge.height = edgeW;
        edge.x = cornerW;
        border.addChild(edge);
        edge = new PIXI.Sprite(edgeTexture);
        edge.rotation = Math.PI * 1.5;
        edge.height = edgeW;
        edge.x = cornerW;
        edge.y = FaceRenderer_1.default.HEIGHT;
        border.addChild(edge);
        this._border = border;
        this._border.visible = this._borderVisibility;
    }
    registerDefaults() {
        this._creator.registerClass(View_1.default);
        this._creator.registerClass(EyeView_1.default);
        this._creator.registerClass(MenuView_1.default);
        this._creator.registerClass(ImageView_1.default);
        this._creator.registerClass(ContactsView_1.default);
        this._creator.registerClass(TextView_1.default);
        this._creator.registerClass(Button_1.default);
        this._creator.registerClass(StandardButton_1.default);
        this._creator.registerClass(ElementGroup_1.default);
        this._creator.registerClass(Label_1.default);
        this._creator.registerClass(List_1.default);
        this._creator.registerClass(Clip_1.default);
        this._creator.registerClass(MenuButton_1.default, MenuButton_1.default.SKILL);
        this._creator.registerClass(MenuButton_1.default, MenuButton_1.default.ACTION);
        this._creator.registerClass(MenuButton_1.default, MenuButton_1.default.ACTION_BIG);
        this._creator.registerClass(ContactButton_1.default);
        this._creator.registerClass(ContentButton_1.default);
    }
    checkViewsValid(views) {
        if (views) {
            if (Array.isArray(views)) {
                for (let i = 0; i < views.length; i++) {
                    if (views[i].state === View_1.STATE.DESTROYED) {
                        return false;
                    }
                }
            }
            else {
                return views.state !== View_1.STATE.DESTROYED;
            }
            return true;
        }
        return false;
    }
    logEvents() {
        this.events.process.removeAllListeners();
        this.events.view.removeAllListeners();
        this.events.process.on((data) => {
            log.info('View process:', data);
        });
        this.events.view.on((data) => {
            log.info('View status:', data);
        });
    }
}
ViewManager._transTime = DEFAULT_TRANS_TIME;
exports.default = ViewManager;

},{"../../Runtime":1,"../../bt/mim/MimManager":52,"../FaceRenderer":99,"./Component":121,"./ComponentCreator":122,"./ComponentGroup":123,"./TouchManager":125,"./ViewGlobalEvents":126,"./ViewProcess":128,"./ViewState":129,"./actions/ActionData":130,"./components/Button":132,"./components/Clip":133,"./components/ContactButton":134,"./components/ContentButton":135,"./components/Element":136,"./components/ElementGroup":137,"./components/Label":138,"./components/List":139,"./components/MenuButton":141,"./components/StandardButton":142,"./log":149,"./views/ContactsView":150,"./views/EyeView":151,"./views/ImageView":152,"./views/MenuView":153,"./views/TextView":155,"./views/View":156,"async":undefined}],128:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const View_1 = require("./views/View");
const log_1 = require("./log");
const log = log_1.default.createChild('ViewProcess');
class ViewProcess {
    constructor() {
        this.changeOptions = null;
        this.onComplete = null;
        this.onFailure = null;
        this.onLoaded = null;
        this.processQueue = [];
        this.status = '';
        this._active = false;
        this._activeViews = [];
        this._currentView = null;
        this._closingView = null;
        this._interrupted = false;
    }
    static get QUEUED() { return 'queued'; }
    static get STARTED() { return 'started'; }
    static get COMPLETED() { return 'completed'; }
    static get INTERRUPTED() { return 'interrupted'; }
    static get FAILED() { return 'failed'; }
    get active() { return this._active; }
    get currentView() {
        return this._currentView;
    }
    set currentView(view) {
        this._currentView = view;
    }
    get closingView() {
        return this._closingView;
    }
    set closingView(view) {
        this._closingView = view;
    }
    get interrupted() {
        return this._interrupted;
    }
    static serializeOptions(options) {
        let serialised = {};
        let value;
        Object.keys(options).forEach((key) => {
            value = options[key];
            if (typeof value === 'string' || typeof value === 'boolean') {
                serialised[key] = value;
            }
            else if (key === 'addView') {
                serialised.addView = `id: ${value.id} type: ${value.type}`;
            }
            else {
                try {
                    serialised[key] = JSON.parse(JSON.stringify(value));
                }
                catch (e) {
                }
            }
        });
        return serialised;
    }
    start(onComplete, onFailure, onLoaded, changeOptions) {
        this.clear();
        this._active = true;
        this._interrupted = false;
        this.onComplete = onComplete;
        this.onFailure = onFailure;
        this.onLoaded = onLoaded;
        this.changeOptions = changeOptions;
        this.status = ViewProcess.STARTED;
    }
    storeView(view) {
        if (view) {
            this._activeViews.push(view);
        }
        else {
            log.info('storeView() given undefined view');
        }
    }
    complete(view) {
        if (this._active && !this._interrupted) {
            this._active = false;
            this._closingView = null;
            this.changeOptions = null;
            this.onFailure = null;
            this.onLoaded = null;
            this._activeViews.length = 0;
            this.status = ViewProcess.COMPLETED;
            if (this.onComplete) {
                let callback = this.onComplete;
                this.onComplete = null;
                callback(view);
                callback = null;
            }
        }
        else {
            log.warn('complete() called but active:' + this._active + ' and interrupted: ' + this._interrupted);
            this.clear();
        }
    }
    fail(retainCurrent = false) {
        this._active = false;
        this.onComplete = null;
        this.onLoaded = null;
        this.changeOptions = null;
        let view;
        for (let i = 0; i < this._activeViews.length; i++) {
            view = this._activeViews[i];
            if (view.state !== View_1.STATE.DESTROYED) {
                if (!retainCurrent || view !== this._currentView) {
                    view.destroyAll();
                }
            }
        }
        this._activeViews.length = 0;
        this.status = ViewProcess.FAILED;
        if (this._currentView) {
            if (!retainCurrent) {
                if (this._currentView.state === View_1.STATE.DESTROYED) {
                    this._currentView = null;
                }
                else {
                    log.warn('fail() currentView was not yet destroyed, is should have been');
                }
            }
            else {
                this._currentView.transitionHandler = null;
            }
        }
        if (this._closingView) {
            if (this._closingView.state === View_1.STATE.DESTROYED) {
                this._closingView = null;
            }
            else {
                log.warn('fail() closingView was not yet destroyed, is should have been');
            }
        }
        if (this.onFailure) {
            let callback = this.onFailure;
            this.onFailure = null;
            callback();
            callback = null;
        }
    }
    interrupt(changeOptions) {
        if (this._active) {
            log.info('View change interruption : ', ViewProcess.serializeOptions(changeOptions), ' interrupting ', ViewProcess.serializeOptions(this.changeOptions), ', interruption should be avoided.');
            this._interrupted = true;
            this.status = ViewProcess.INTERRUPTED;
            return true;
        }
        return false;
    }
    addProcessToQueue(changeOptions, onComplete, onFailure, onLoaded) {
        const viewProcess = new ViewProcess();
        viewProcess.changeOptions = changeOptions;
        viewProcess.onComplete = onComplete;
        viewProcess.onFailure = onFailure;
        viewProcess.onLoaded = onLoaded;
        viewProcess.status = ViewProcess.QUEUED;
        this.processQueue.push(viewProcess);
    }
    reset() {
        if (this._active) {
            log.info('View change interruption : due to reset, interrupting ', ViewProcess.serializeOptions(this.changeOptions));
            this._interrupted = true;
            this.status = ViewProcess.INTERRUPTED;
        }
        let view;
        for (let i = 0; i < this._activeViews.length; i++) {
            view = this._activeViews[i];
            if (view.state !== View_1.STATE.DESTROYED) {
                view.destroy();
            }
        }
        if (this._currentView && this._currentView.state !== View_1.STATE.DESTROYED) {
            this._currentView.destroyAll();
        }
        if (this._closingView && this._closingView.state !== View_1.STATE.DESTROYED) {
            this._closingView.destroyAll();
        }
        this._currentView = null;
        this._closingView = null;
        this.clear();
    }
    clear() {
        this._active = false;
        this.onComplete = null;
        this.onFailure = null;
        this.onLoaded = null;
        this._activeViews.length = 0;
        this.changeOptions = null;
    }
}
exports.default = ViewProcess;

},{"./log":149,"./views/View":156}],129:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class ViewState {
    constructor(viewClassName = 'View', config) {
        this.id = '';
        this.configPath = '';
        this.viewClassName = '';
        this.viewConfig = null;
        this.pauseParent = false;
        this.ignoreSwipeDown = false;
        if (viewClassName) {
            this.viewClassName = viewClassName;
        }
        if (config) {
            this.applyConfig(config);
        }
    }
    applyConfig(config) {
        if (config) {
            if (config.hasOwnProperty('viewConfig')) {
                this.viewConfig = config.viewConfig;
                if (this.viewConfig.hasOwnProperty('type')) {
                    this.viewClassName = this.viewConfig.type;
                }
                if (this.viewConfig.hasOwnProperty('id')) {
                    this.id = this.viewConfig.id;
                }
            }
            if (config.hasOwnProperty('componentConfigs')) {
                this.componentConfigs = config.componentConfigs;
            }
        }
    }
}
exports.default = ViewState;

},{}],130:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class ActionData {
    constructor(type, data) {
        this.type = "";
        this.data = null;
        this.type = type;
        this.data = data;
    }
    static get CHANGE_VIEW() { return "changeView"; }
    static get OPEN_VIEW() { return "openView"; }
    static get CLOSE_VIEW() { return "closeView"; }
    static get CLOSE_VIEW_EMPTY() { return "closeViewEmpty"; }
    static get CLOSE_ALL() { return "closeAll"; }
    static get CLOSE_ALL_OPEN() { return "closeAllOpen"; }
    static get CLOSE_ALL_EMPTY() { return "closeAllEmpty"; }
    static get SWIPE_RIGHT() { return "swipeRight"; }
    static get SWIPE_LEFT() { return "swipeLeft"; }
    static get SWIPE_DOWN() { return "swipeDown"; }
    static get SWIPE_UP() { return "swipeUp"; }
    static get GO_TO_BEGINNING() { return "goToBeginning"; }
    static get GO_TO_END() { return "goToEnd"; }
    static get EVENT() { return "event"; }
    static get SOUND() { return "sound"; }
    static get UTTERANCE() { return "utterance"; }
    static get VERBAL_COMMAND() { return "verbalCommand"; }
    static get MIM_END() { return "mimEnd"; }
    static get MIM_SHOW_GUI() { return "mimShowGUI"; }
    static get CALLBACK() { return "callback"; }
    static createFromConfig(configData) {
        let actionData = new ActionData();
        actionData.applyConfig(configData);
        return actionData;
    }
    applyConfig(configData) {
        if (configData.hasOwnProperty("type")) {
            this.type = configData.type;
        }
        if (configData.hasOwnProperty("data")) {
            this.data = configData.data;
        }
    }
}
exports.default = ActionData;

},{}],131:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const ActionData_1 = require("./ActionData");
exports.default = {
    ActionData: ActionData_1.default
};

},{"./ActionData":130}],132:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Element_1 = require("./Element");
const TouchManager_1 = require("../TouchManager");
const Runtime_1 = require("../../../Runtime");
const animate = require("pixi-animate");
const log_1 = require("./log");
const log = log_1.default.createChild('Button');
class Button extends Element_1.default {
    constructor() {
        super();
        this.timeline = null;
        this._type = Button.DEFAULT_TYPE;
        this.isDown = false;
        this.interactable = true;
    }
    static get DEFAULT_TYPE() { return 'Button'; }
    static createFromConfig(configData) {
        let btn = new Button();
        btn.assignConfig(configData);
        return btn;
    }
    static createFromDisplayObject(displayObject, actionData, container = null) {
        let btn = new Button();
        btn.display = new PIXI.Container();
        if (container) {
            container.addChild(btn.display);
        }
        else if (displayObject.parent) {
            displayObject.parent.addChild(btn.display);
        }
        if (actionData) {
            btn.addAction(actionData);
        }
        btn.setupHitArea();
        btn.setupInteractions();
        btn.display.addChild(displayObject);
        return btn;
    }
    setupDisplay(assets) {
        let asset;
        let assetDescriptor;
        for (let i = 0; i < this._assetDescriptors.length; i++) {
            assetDescriptor = this._assetDescriptors[i];
            asset = assets[assetDescriptor.id];
            if (assetDescriptor.hasOwnProperty('type')) {
                switch (assetDescriptor.type) {
                    case 'texture':
                        let sprite = new PIXI.Sprite(asset);
                        this.display.addChild(sprite);
                        break;
                    case 'timeline':
                        let movieClip = new asset.library.stage();
                        this.display.addChild(movieClip);
                        if (assetDescriptor.upload) {
                            Runtime_1.default.instance.face.plugins.prepare.upload(movieClip);
                        }
                        break;
                    default:
                        log.debug('setupDisplay() will not setup for asset type: ' + asset.type);
                }
            }
            else {
                log.debug('Button :: assignAssets() no type given for asset: ' + asset + ', assuming bitmap');
                let sprite = PIXI.Sprite.from(asset);
                this.display.addChild(sprite);
            }
        }
        this.setupHitArea();
        this.setupInteractions();
    }
    setupHitArea(bounds) {
        if (this.display) {
            if (bounds) {
                this.display.hitArea = bounds;
            }
            else if (this._hitArea) {
                this.display.hitArea = this._hitArea;
            }
            else {
                bounds = this.display.getBounds();
                bounds.x = bounds.y = 0;
                this.display.hitArea = bounds;
            }
        }
    }
    setupInteractions() {
        if (this.display && this.interactable) {
            this.display.interactiveChildren = false;
            this.display.interactive = !this.inputLocked;
            this.display.addListener('mouseout', this.out.bind(this));
            this.display.addListener('mousedown', this.down.bind(this));
            this.display.addListener('mouseup', this.up.bind(this));
        }
    }
    lockInput(flag) {
        super.lockInput(flag);
        if (this.interactable && this.display) {
            if (flag && this.isDown) {
                this.up();
            }
        }
    }
    click() {
        if (this.timeline) {
            animate.Animator.stop(this.timeline);
        }
        super.triggerActions(TouchManager_1.GESTURE.TAP);
    }
    out(mouseData) {
        if (this.isDown) {
            this.isDown = false;
            if (this.timeline) {
                animate.Animator.play(this.timeline, 'out');
            }
        }
    }
    down(mouseData) {
        this.isDown = true;
        if (this.timeline) {
            animate.Animator.play(this.timeline, 'down');
        }
    }
    up(mouseData) {
        this.isDown = false;
        if (this.timeline) {
            animate.Animator.play(this.timeline, 'up');
        }
    }
    activate() {
        if (this.timeline) {
            animate.Animator.play(this.timeline, 'activate');
        }
    }
    destroy() {
        if (this.display) {
            this.display.removeAllListeners('mouseout');
            this.display.removeAllListeners('mousedown');
            this.display.removeAllListeners('mouseup');
            this.display.removeAllListeners('click');
        }
        this.timeline = null;
        super.destroy();
    }
}
exports.default = Button;

},{"../../../Runtime":1,"../TouchManager":125,"./Element":136,"./log":144,"pixi-animate":undefined}],133:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Element_1 = require("./Element");
const Runtime_1 = require("../../../Runtime");
const log_1 = require("./log");
const log = log_1.default.createChild('Clip');
class Clip extends Element_1.default {
    constructor() {
        super(...arguments);
        this.timeline = null;
        this.movieClip = null;
        this._type = Clip.DEFAULT_TYPE;
    }
    static get DEFAULT_TYPE() { return 'Clip'; }
    static createFromConfig(configData) {
        const clip = new Clip();
        clip.assignConfig(configData);
        return clip;
    }
    static createFromDisplayObject(displayObject, container) {
        const clip = new Clip();
        clip.display = new PIXI.Container();
        if (container) {
            container.addChild(clip.display);
        }
        else if (displayObject.parent) {
            displayObject.parent.addChild(clip.display);
        }
        clip.display.addChild(displayObject);
        return clip;
    }
    setupDisplay(assets) {
        let asset;
        let assetDescriptor;
        if (this._assetDescriptors) {
            for (let i = 0; i < this._assetDescriptors.length; i++) {
                assetDescriptor = this._assetDescriptors[i];
                asset = assets[assetDescriptor.id];
                if (asset) {
                    if (assetDescriptor.hasOwnProperty("type")) {
                        switch (assetDescriptor.type) {
                            case "texture":
                                this.display.addChild(new PIXI.Sprite(asset));
                                break;
                            case "timeline":
                                this.timeline = asset;
                                if (this.timeline) {
                                    this.movieClip = new this.timeline.library.stage();
                                    this.display.addChild(this.movieClip);
                                    if (assetDescriptor.upload) {
                                        Runtime_1.default.instance.face.plugins.prepare.upload(this.movieClip);
                                    }
                                }
                                else {
                                    log.warn("setupDisplay() invaid timeline asset given", asset);
                                }
                                break;
                            default:
                                break;
                        }
                    }
                    else {
                        log.warn('setupDisplay() : no type given for asset: ' + asset + ' of id: ' + assetDescriptor.id + ', assuming bitmap');
                        let sprite = PIXI.Sprite.from(asset);
                        this.display.addChild(sprite);
                    }
                }
                else {
                    log.warn("setupDisplay() : no asset found with id: " + assetDescriptor.id);
                }
            }
        }
    }
    destroy() {
        this.movieClip = null;
        this.timeline = null;
        super.destroy();
    }
}
exports.default = Clip;

},{"../../../Runtime":1,"./Element":136,"./log":144}],134:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const MenuButton_1 = require("./MenuButton");
const Label_1 = require("./Label");
const ActionData_1 = require("../actions/ActionData");
const Runtime_1 = require("../../../Runtime");
const animate = require("pixi-animate");
const log_1 = require("./log");
const log = log_1.default.createChild('Contactsbutton');
class ContactButton extends MenuButton_1.default {
    constructor() {
        super();
        this._type = ContactButton.DEFAULT_TYPE;
        this._looper = null;
        this.colors = [0xbac5c9, 0x434d55];
        super.addButtonData(ContactButton.DEFAULT_TYPE, 'core://resources/buttons/contactButton.js', { width: 330, height: 330 });
        this.toggleAnimate = this.animateToggleState;
    }
    static get DEFAULT_TYPE() { return 'ContactButton'; }
    get looper() { return this._looper; }
    static createFromConfig(configData) {
        let btn = new ContactButton();
        btn.assignConfig(configData);
        return btn;
    }
    applyButtonType(type) {
        super.applyButtonType(type);
        if (this._looper) {
            const photoAsset = this._looper.getAssets('photo')[0];
            if (photoAsset) {
                const url = photoAsset.fullFilenameOrURL();
                if (url) {
                    super.addAssetDescriptor(this._looper.id, url, 'texture');
                }
            }
        }
    }
    destroy() {
        this._looper = null;
        super.destroy();
    }
    assignLooper(looper) {
        this._looper = looper;
        this.label = looper.getWrittenName();
        this.id = looper.id;
        this.addAction(ActionData_1.default.UTTERANCE, {
            utterance: {
                intent: 'loopmember',
                entities: {
                    loopMemberReferent: looper.id
                }
            }
        });
    }
    setupTimeline(assets) {
        if (assets.hasOwnProperty(this.timelineId)) {
            let movieClip = new assets[this.timelineId].library.stage();
            this._content = movieClip['content'];
            const imageContainer = this._content['icon'];
            const photoTexture = this._assets[this._looper.id];
            if (photoTexture) {
                const photoSprite = new PIXI.Sprite(photoTexture);
                photoSprite.width = this._dimensions.width;
                photoSprite.height = this._dimensions.height;
                photoSprite.anchor.x = photoSprite.anchor.y = .5;
                photoSprite.setParent(imageContainer);
                this._content['background'].visible = false;
                this._content['gradient'].visible = false;
                this._content['border'].visible = false;
            }
            else {
                if (this.colors) {
                    this._content['background'].children[0].tint = this.colors[0];
                    this._content['gradient'].children[0].tint = this.colors[1];
                }
                const initialText = new PIXI.Text(this._looper.getInitials(), Label_1.default.createFontStyle(135, 'Proxima Nova Soft', '#FFFFFF', 'bold'));
                initialText.anchor.x = initialText.anchor.y = .5;
                imageContainer.addChild(initialText);
            }
            this.display.addChild(movieClip);
            Runtime_1.default.instance.face.plugins.prepare.upload(movieClip);
            this.toggleAnimate(false, false);
        }
        else {
            log.warn('createDisplay() timeline not found in assets');
        }
    }
    toggleDownTransition() {
    }
    click() {
        if (this.willToggle) {
            this.toggle(!this.toggledOn, true);
        }
        super.click();
    }
    animateToggleState(toggleOn = false, shouldAnimate = true) {
        if (this._content) {
            const checkClip = this._content['check'];
            if (checkClip) {
                let label = toggleOn ? 'check_open' : 'check_close';
                if (shouldAnimate) {
                    animate.Animator.play(checkClip, label);
                }
                else {
                    checkClip.gotoAndStop(label + '_stop');
                }
            }
        }
    }
}
exports.default = ContactButton;

},{"../../../Runtime":1,"../actions/ActionData":130,"./Label":138,"./MenuButton":141,"./log":144,"pixi-animate":undefined}],135:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const MenuButton_1 = require("./MenuButton");
const Runtime_1 = require("../../../Runtime");
const log_1 = require("./log");
const log = log_1.default.createChild('ContentButton');
class ContentButton extends MenuButton_1.default {
    constructor() {
        super();
        this._type = ContentButton.DEFAULT_TYPE;
        super.addButtonData(ContentButton.DEFAULT_TYPE, 'core://resources/buttons/contentButton.js', { width: 330, height: 330 });
    }
    static get DEFAULT_TYPE() { return 'ContentButton'; }
    static createFromConfig(configData) {
        let btn = new ContentButton();
        btn.assignConfig(configData);
        return btn;
    }
    assignConfig(configData) {
        super.assignConfig(configData);
        this._isVideo = !!configData.isVideo;
        this._albumInfo = configData.albumInfo;
    }
    destroy() {
        super.destroy();
    }
    setupTimeline(assets) {
        if (assets.hasOwnProperty(this.timelineId)) {
            const movieClip = new assets[this.timelineId].library.stage();
            const sprite = new PIXI.Sprite();
            sprite.texture = assets[this.iconId];
            const content = this._content = movieClip['content'];
            content.target.addChild(sprite);
            this.display.addChild(movieClip);
            Runtime_1.default.instance.face.plugins.prepare.upload(movieClip);
        }
        else {
            log.warn('createDisplay() timeline not found in assets');
        }
    }
}
exports.default = ContentButton;

},{"../../../Runtime":1,"./MenuButton":141,"./log":144}],136:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Component_1 = require("../Component");
const TweenManager_1 = require("../../tween/TweenManager");
const FaceRenderer_1 = require("../../FaceRenderer");
const ViewManager_1 = require("../ViewManager");
const DisplayUtils_1 = require("../DisplayUtils");
const log_1 = require("./log");
const log = log_1.default.createChild('Element');
class Element extends Component_1.default {
    constructor() {
        super(...arguments);
        this.interactable = false;
        this._targetPosition = null;
        this._transformData = null;
        this._hitArea = null;
        this._display = null;
    }
    static get PARENT_ELEMENT() { return 'parentElement'; }
    set display(display) {
        display[Element.PARENT_ELEMENT] = this;
        this._display = display;
    }
    get display() {
        return this._display;
    }
    get targetPosition() {
        if (!this._targetPosition) {
            this._targetPosition = new PIXI.Point();
        }
        return this._targetPosition;
    }
    get transformData() {
        return this._transformData;
    }
    set setTransformData(transformData) {
        this._transformData = transformData;
    }
    assignConfig(configData) {
        if (configData) {
            super.assignConfig(configData);
            if (configData.hasOwnProperty('position')) {
                this._targetPosition = DisplayUtils_1.default.getElementPosition(configData.position);
            }
            if (configData.hasOwnProperty('transform')) {
                this._transformData = configData.transform;
            }
            if (configData.hasOwnProperty('hitArea')) {
                this._hitArea = new PIXI.Rectangle(Number(configData.hitArea.x), Number(configData.hitArea.y), Number(configData.hitArea.width), Number(configData.hitArea.height));
            }
            if (configData.hasOwnProperty('interactable')) {
                this.interactable = configData.interactable;
            }
        }
    }
    updateConfig(configData) {
        return configData;
    }
    update(elapsed) {
        log.info("update() : class has not overridden its update, which means update probably shouldn't be getting called on it.");
    }
    createDisplay(container, assets) {
        this._assets = assets;
        this.display = new PIXI.Container();
        this.setupDisplay(assets);
        this.applyPosition();
        container.addChild(this._display);
    }
    setupDisplay(assets) {
    }
    emptyDisplay() {
        this.stopChildTweens();
        if (this.display && this.display.children) {
            let childDisplay;
            for (let i = this.display.children.length - 1; i >= 0; i--) {
                childDisplay = this.display.children[i];
                if (childDisplay instanceof PIXI.Container) {
                    childDisplay.destroy({ children: true });
                }
                else {
                    childDisplay.destroy();
                }
            }
        }
    }
    stopChildTweens(includeDisplay = false) {
        if (this._display) {
            TweenManager_1.default.stopCheck(DisplayUtils_1.default.isContained, this._display);
            if (includeDisplay) {
                TweenManager_1.default.stop(this._display);
            }
        }
    }
    ready() {
    }
    setTargetPosition(x = 0, y = 0, applyNow = false) {
        if (!this._targetPosition) {
            this._targetPosition = new PIXI.Point();
        }
        this._targetPosition.x = x;
        this._targetPosition.y = y;
        if (applyNow && this._display) {
            this._display.x = x;
            this._display.y = y;
        }
    }
    applyPosition() {
        if (this._display) {
            if (this._targetPosition) {
                this._display.x = this._targetPosition.x;
                this._display.y = this._targetPosition.y;
            }
            if (this._transformData) {
                if (this._transformData.scaleX && this._transformData.scaleY) {
                    this._display.scale = { x: Number(this._transformData.scaleX), y: Number(this._transformData.scaleY) };
                }
                if (this._transformData.pivotX && this._transformData.pivotY) {
                    this._display.pivot = { x: Number(this._transformData.pivotX) * this._display.width, y: Number(this._transformData.pivotY) * this._display.height };
                }
                if (this.transformData.rotate && this._transformData.rotate !== 0) {
                    this._display.rotation = this._transformData.rotate * PIXI.DEG_TO_RAD;
                    this._display.x += this._display.pivot.x;
                    this._display.y += this._display.pivot.y;
                }
            }
        }
    }
    open(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME, tweenType = 'backOut') {
        const targetY = this._display.y;
        const originY = +targetY + +FaceRenderer_1.default.HEIGHT;
        TweenManager_1.default.stop(this._display);
        TweenManager_1.default.play(this._display, {
            to: { y: targetY },
            from: { y: originY },
            duration: duration,
            ease: tweenType
        }, callback);
    }
    close(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME, tweenType = 'backIn') {
        const targetY = +this._display.y + +FaceRenderer_1.default.HEIGHT;
        TweenManager_1.default.stop(this._display);
        TweenManager_1.default.play(this._display, {
            to: { y: targetY },
            duration: duration,
            ease: tweenType
        }, callback);
    }
    destroy() {
        if (this._display) {
            TweenManager_1.default.stop(this._display);
            delete this._display['parentElement'];
            this._display = null;
        }
        this._targetPosition = null;
        this._transformData = null;
        this._hitArea = null;
        super.destroy();
    }
    lockInput(flag) {
        super.lockInput(flag);
        if (this.interactable && this._display) {
            this._display.interactive = !this._inputLocked;
        }
    }
    centerPivot() {
        if (this.display) {
            const bounds = this.display.getLocalBounds();
            const width = bounds.width / 2;
            const height = bounds.height / 2;
            this.display.pivot.x = width;
            this.display.pivot.y = height;
            this.display.x += width;
            this.display.y += height;
        }
    }
}
exports.default = Element;

},{"../../FaceRenderer":99,"../../tween/TweenManager":174,"../Component":121,"../DisplayUtils":124,"../ViewManager":127,"./log":144}],137:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const ComponentGroup_1 = require("../ComponentGroup");
const TweenManager_1 = require("../../tween/TweenManager");
const FaceRenderer_1 = require("../../FaceRenderer");
const ViewManager_1 = require("../ViewManager");
const DisplayUtils_1 = require("../DisplayUtils");
class ElementGroup extends ComponentGroup_1.default {
    constructor() {
        super(...arguments);
        this.interactable = false;
        this._targetPosition = null;
        this._display = null;
    }
    static get DEFAULT_TYPE() {
        return 'ElementGroup';
    }
    static get PARENT_ELEMENT() { return 'parentElement'; }
    set display(display) {
        display[ElementGroup.PARENT_ELEMENT] = this;
        this._display = display;
    }
    get display() {
        return this._display;
    }
    get targetPosition() {
        if (!this._targetPosition) {
            this._targetPosition = new PIXI.Point();
        }
        return this._targetPosition;
    }
    static createFromConfig(configData) {
        let elementGroup = new ElementGroup();
        elementGroup.assignConfig(configData);
        if (configData.componentConfigs) {
            elementGroup.createComponentsFromConfigs(configData.componentConfigs);
        }
        return elementGroup;
    }
    assignConfig(configData) {
        if (configData) {
            super.assignConfig(configData);
            if (configData.hasOwnProperty("position")) {
                this._targetPosition = DisplayUtils_1.default.getElementPosition(configData.position);
            }
            if (configData.hasOwnProperty("interactable")) {
                this.interactable = configData.interactable;
            }
        }
    }
    createDisplay(container, assets) {
        this.display = new PIXI.Container();
        this.applyPosition();
        container.addChild(this.display);
        super.createDisplay(this.display, assets);
    }
    setupDisplay(assets) {
        if (this.componentList) {
            const length = this.componentList.length;
            for (let i = 0; i < length; i++) {
                this.componentList[i].setupDisplay(assets);
            }
        }
    }
    emptyDisplay() {
        this.stopChildTweens();
        if (this.componentList) {
            const length = this.componentList.length;
            for (let i = 0; i < length; i++) {
                this.componentList[i].emptyDisplay();
            }
        }
    }
    stopChildTweens(includeDisplay = false) {
        if (this._display) {
            TweenManager_1.default.stopCheck(DisplayUtils_1.default.isContained, this._display);
            if (includeDisplay) {
                TweenManager_1.default.stop(this._display);
            }
        }
        if (this.componentList) {
            const length = this.componentList.length;
            for (let i = 0; i < length; i++) {
                this.componentList[i].stopChildTweens(includeDisplay);
            }
        }
    }
    setTargetPosition(x = 0, y = 0, applyNow = false) {
        if (!this._targetPosition) {
            this._targetPosition = new PIXI.Point();
        }
        this._targetPosition.x = x;
        this._targetPosition.y = y;
        if (applyNow && this._display) {
            this._display.x = x;
            this._display.y = y;
        }
    }
    applyPosition() {
        if (this._display) {
            if (this._targetPosition) {
                this._display.x = this._targetPosition.x;
                this._display.y = this._targetPosition.y;
            }
        }
    }
    open(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME, tweenType = 'backOut') {
        const targetY = this._display.y;
        const originY = +targetY + +FaceRenderer_1.default.HEIGHT;
        TweenManager_1.default.stop(this._display);
        TweenManager_1.default.play(this._display, {
            to: { y: targetY },
            from: { y: originY },
            duration: duration,
            ease: tweenType
        }, callback);
    }
    close(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME, tweenType = 'backIn') {
        const targetY = +this._display.y + +FaceRenderer_1.default.HEIGHT;
        TweenManager_1.default.stop(this._display);
        TweenManager_1.default.play(this._display, {
            to: { y: targetY },
            duration: duration,
            ease: tweenType
        }, callback);
    }
    destroy() {
        if (this._display) {
            TweenManager_1.default.stop(this._display);
            delete this._display['parentElement'];
            this._display = null;
        }
        this._targetPosition = null;
        super.destroy();
    }
    lockInput(flag) {
        super.lockInput(flag);
        if (this.interactable && this._display) {
            this._display.interactive = !this._inputLocked;
        }
    }
}
exports.default = ElementGroup;

},{"../../FaceRenderer":99,"../../tween/TweenManager":174,"../ComponentGroup":123,"../DisplayUtils":124,"../ViewManager":127}],138:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Element_1 = require("./Element");
const TweenManager_1 = require("../../tween/TweenManager");
const ViewManager_1 = require("../ViewManager");
const Runtime_1 = require("../../../Runtime");
const log_1 = require("./log");
const log = log_1.default.createChild('Clip');
class Label extends Element_1.default {
    constructor() {
        super(...arguments);
        this._type = Label.DEFAULT_TYPE;
        this.style = null;
        this.textDisplay = null;
        this._bounds = null;
        this._targetAnchor = null;
        this._text = '';
    }
    static get DEFAULT_TYPE() { return 'Label'; }
    get bounds() { return this._bounds; }
    set bounds(newBounds) {
        this._bounds = newBounds;
        this.applyTextBounds();
    }
    get targetAnchor() {
        if (!this._targetAnchor) {
            this._targetAnchor = new PIXI.Point();
        }
        return this._targetAnchor;
    }
    get text() { return this._text; }
    set text(newText) {
        this._text = newText;
        if (this.textDisplay) {
            this.textDisplay.text = this._text;
            this.applyTextBounds();
        }
    }
    static createFontStyle(size, family, color, style, align) {
        let fontStyle = new PIXI.TextStyle({
            fontSize: Number(size) || size,
            fontFamily: family,
            fill: color,
            fontStyle: style,
            align: align
        });
        return fontStyle;
    }
    static createFromConfig(configData) {
        let label = new Label();
        label.assignConfig(configData);
        return label;
    }
    assignConfig(configData) {
        super.assignConfig(configData);
        if (configData.hasOwnProperty('text')) {
            this._text = configData.text;
        }
        if (configData.hasOwnProperty('style')) {
            this.style = new PIXI.TextStyle(configData.style);
            if (this.style.fontSize) {
                this.style.fontSize = Number(this.style.fontSize) || this.style.fontSize;
            }
        }
        if (configData.hasOwnProperty('bounds')) {
            this._bounds = { width: Number(configData.bounds.width), height: Number(configData.bounds.height) };
        }
        if (configData.hasOwnProperty('targetAnchor')) {
            this._targetAnchor = new PIXI.Point(Number(configData.targetAnchor.x), Number(configData.targetAnchor.y));
        }
    }
    setupDisplay(assets) {
        if (!this.style) {
            this.style = Label.DEFAULT_STYLE.clone();
        }
        this.textDisplay = new PIXI.Text(this.text, this.style);
        this._originalFontSize = this.getFontSize(this.style);
        this.applyTextBounds();
        this.display.addChild(this.textDisplay);
        Runtime_1.default.instance.face.plugins.prepare.upload(this.textDisplay);
    }
    getTextDimensions(sampleText) {
        sampleText = (this.text) ? this.text : sampleText;
        sampleText = (sampleText) ? sampleText : 'Sample';
        try {
            let textMetric = PIXI.TextMetrics.measureText(sampleText, this.style);
            return { width: textMetric.width, height: textMetric.height };
        }
        catch (err) {
            log.error('Error occured requesting PIXI.TextMetrics for text: ' + sampleText + ', with style :', this.style, ' error:', err);
            return null;
        }
    }
    setTargetAnchor(x = 0, y = 0, applyNow = false) {
        if (!this._targetAnchor) {
            this._targetAnchor = new PIXI.Point();
        }
        this._targetAnchor.x = x;
        this._targetAnchor.y = y;
        if (applyNow && this.textDisplay) {
            this.textDisplay.anchor.x = x;
            this.textDisplay.anchor.y = y;
        }
    }
    applyPosition() {
        super.applyPosition();
        if (this.textDisplay && this._targetAnchor) {
            this.textDisplay.anchor.x = this._targetAnchor.x;
            this.textDisplay.anchor.y = this._targetAnchor.y;
        }
    }
    open(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME, tweenType = 'sineOut') {
        TweenManager_1.default.stop(this.display);
        TweenManager_1.default.play(this.display, {
            to: { alpha: 1 },
            from: { alpha: 0 },
            duration: duration,
            ease: tweenType
        }, callback);
    }
    close(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME, tweenType = 'sineIn') {
        TweenManager_1.default.stop(this.display);
        TweenManager_1.default.play(this.display, {
            to: { alpha: 0 },
            duration: duration,
            ease: tweenType
        }, callback);
    }
    destroy() {
        this.style = null;
        if (this.textDisplay) {
            this.textDisplay.destroy(true);
            this.textDisplay = null;
        }
        this._targetAnchor = null;
        this._bounds = null;
        super.destroy();
    }
    applyTextBounds() {
        const bounds = this.bounds;
        if (bounds && this.textDisplay && this.textDisplay.text) {
            let fontSize = this.getFontSize(this.style);
            if (this._originalFontSize !== fontSize) {
                this.style.fontSize = this._originalFontSize;
                fontSize = this.style.fontSize;
            }
            let dimensions = this.getTextDimensions();
            bounds.width = bounds.width ? bounds.width : dimensions.width;
            bounds.height = bounds.height ? bounds.height : dimensions.height;
            let refitCount = 0;
            if (dimensions.width > bounds.width || dimensions.height > bounds.height) {
                let fontResize = Math.ceil(fontSize / 2);
                let subtract = true;
                while (fontResize > 1) {
                    refitCount++;
                    if (dimensions.width > bounds.width || dimensions.height > bounds.height) {
                        if (!subtract) {
                            subtract = true;
                            fontResize = Math.ceil(fontResize / 2);
                        }
                        if (fontResize === fontSize) {
                            fontResize = Math.floor(fontResize / 2);
                        }
                        this.style.fontSize = fontSize -= fontResize;
                        dimensions = this.getTextDimensions();
                    }
                    else {
                        if (subtract) {
                            subtract = false;
                            fontResize = Math.ceil(fontResize / 2);
                        }
                        this.style.fontSize = fontSize += fontResize;
                        dimensions = this.getTextDimensions();
                    }
                }
                log.debug(' took ' + refitCount + ' iterations to resize text ' + this.textDisplay.text);
            }
        }
    }
    getFontSize(style) {
        let fontSize = (typeof style.fontSize === 'string') ? parseInt(style.fontSize) : style.fontSize;
        if (isNaN(fontSize)) {
            return Number(Label.DEFAULT_STYLE.fontSize);
        }
        return fontSize;
    }
}
Label.DEFAULT_STYLE = new PIXI.TextStyle({
    fontSize: 60,
    fontFamily: "Proxima Nova Soft",
    fill: "#FFFFFF"
});
exports.default = Label;

},{"../../../Runtime":1,"../../tween/TweenManager":174,"../ViewManager":127,"./Element":136,"./log":144}],139:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Button_1 = require("../components/Button");
const ComponentGroup_1 = require("../ComponentGroup");
const ComponentCreator_1 = require("../ComponentCreator");
const ViewManager_1 = require("../ViewManager");
const ActionData_1 = require("../actions/ActionData");
const FaceRenderer_1 = require("../../FaceRenderer");
const TweenManager_1 = require("../../tween/TweenManager");
const Runtime_1 = require("../../../Runtime");
const TouchManager_1 = require("../TouchManager");
const DisplayUtils_1 = require("../DisplayUtils");
const ListMember_1 = require("./subcomponents/ListMember");
const log_1 = require("./log");
const log = log_1.default.createChild('List');
var Movement;
(function (Movement) {
    Movement[Movement["NONE"] = 0] = "NONE";
    Movement[Movement["PAN"] = 1] = "PAN";
    Movement[Movement["SWIPE"] = 2] = "SWIPE";
})(Movement || (Movement = {}));
var PanCase;
(function (PanCase) {
    PanCase[PanCase["STILL"] = 0] = "STILL";
    PanCase[PanCase["DYNAMIC"] = 1] = "DYNAMIC";
    PanCase[PanCase["CLAMP_LEFT"] = 2] = "CLAMP_LEFT";
    PanCase[PanCase["CLAMP_RIGHT"] = 3] = "CLAMP_RIGHT";
})(PanCase || (PanCase = {}));
class List extends ComponentGroup_1.default {
    constructor() {
        super();
        this._type = List.DEFAULT_TYPE;
        this.elementsPerPage = 3;
        this.axis = 'horizontal';
        this.numElementsAtEdge = 1;
        this.elementDimensions = null;
        this.elementBuffer = 20;
        this.defaultElementData = null;
        this.axisPosition = 0;
        this.dynamicLoadBuffer = 1;
        this.noPan = false;
        this.dynamicElements = false;
        this.dynamicPreload = false;
        this.autoFitElements = true;
        this.pageHinting = true;
        this._elementSpacing = 0;
        this._listStartPosition = null;
        this._requiresPan = false;
        this.EDGE_HINT = 80;
        this.BUFFER_SPREAD = 30;
        this.PAN_THRESHOLD = 150;
        this.PAN_SPREAD = 40;
        this.SPRING = .08;
        this.FRICTION = .7;
        this.REST_THRESHOLD = 5;
        this.SWIPE_THRESHOLD = 100;
        this._axis = 'horizontal';
        this._loadingElements = null;
        this._leftPageBound = 0;
        this._rightPageBound = 0;
        this._pageIndex = 0;
        this._pageElementOffset = 0;
        this._indexOfAction = -1;
        this._bufferMax = null;
        this._currentMovement = Movement.NONE;
        this._panTotalDelta = 0;
        this._dynamicActiveIndexRange = null;
        this.onPanEvent = this.onPanEvent.bind(this);
    }
    static get DEFAULT_TYPE() {
        return 'List';
    }
    static get PAN() {
        return 'page_pan';
    }
    static get PAGED() {
        return 'paged';
    }
    static get REMOVE_ELEMENT() { return 'removeElement'; }
    static get AT_END() {
        return 'at_end';
    }
    static get AT_FRONT() {
        return 'at_front';
    }
    get elementSpacing() {
        return this._elementSpacing;
    }
    get listStartPosition() {
        return this._listStartPosition;
    }
    get pageIndex() {
        return this._pageIndex;
    }
    static createFromConfig(configData) {
        let list = new List();
        list.assignConfig(configData);
        return list;
    }
    assignConfig(configData) {
        if (configData) {
            super.assignConfig(configData);
            if (configData.hasOwnProperty('axis')) {
                this._axis = configData['axis'];
            }
            if (configData.hasOwnProperty('position')) {
                if (this._axis === 'horizontal') {
                    this.axisPosition = Number(configData.position['y']);
                }
                else {
                    this.axisPosition = Number(configData.position['x']);
                }
            }
            if (configData.hasOwnProperty('dynamic')) {
                this.dynamicElements = configData['dynamic'];
            }
            if (configData.hasOwnProperty('dynamicPreload')) {
                this.dynamicPreload = configData['dynamicPreload'];
            }
            if (configData.hasOwnProperty('dynamicBuffer')) {
                this.dynamicLoadBuffer = Number(configData['dynamicBuffer']);
            }
            if (configData.hasOwnProperty('noPan')) {
                this.noPan = configData['noPan'];
            }
            if (configData.hasOwnProperty('elementsPerPage')) {
                this.elementsPerPage = Number(configData['elementsPerPage']);
            }
            if (configData.hasOwnProperty('autoFitElements')) {
                this.autoFitElements = configData['autoFitElements'];
            }
            if (configData.hasOwnProperty('pageHinting')) {
                this.pageHinting = configData['pageHinting'];
            }
            if (configData.hasOwnProperty('pageIndex')) {
                this._pageIndex = Number(configData['pageIndex']);
            }
            if (configData.hasOwnProperty('indexOfAction')) {
                this._indexOfAction = Number(configData['indexOfAction']);
            }
            if (configData.hasOwnProperty('elementDimensions')) {
                let width = Number(configData.elementDimensions.width) || Number(configData.elementDimensions.x);
                let height = Number(configData.elementDimensions.height) || Number(configData.elementDimensions.y);
                this.elementDimensions = { width: width, height: height };
            }
            else {
                this.elementDimensions = { width: 300, height: 300 };
            }
            if (configData.hasOwnProperty('elementBuffer')) {
                this.elementBuffer = Number(configData['elementBuffer']);
            }
            let defaultElementData;
            if (configData.hasOwnProperty('defaultElement')) {
                defaultElementData = configData['defaultElement'];
            }
            if (configData.hasOwnProperty('componentConfigs')) {
                this.componentConfigs = configData['componentConfigs'];
                this.createComponentsFromConfigs(this.componentConfigs, defaultElementData);
            }
            this.calculateReferenceValues();
        }
    }
    addComponent(element, elementId) {
        if (element) {
            return super.addComponent(element, elementId);
        }
        return null;
    }
    removeComponent(componentDeterminer, done, transition) {
        let element = super.removeComponent(componentDeterminer);
        if (!element) {
            if (done) {
                done();
            }
            return null;
        }
        const maxPageIndex = this.getPagesCount() - 1;
        let targetPageIndex = this._pageIndex;
        if (this._pageIndex > maxPageIndex) {
            targetPageIndex = maxPageIndex;
            this._pageElementOffset = 0;
        }
        if (targetPageIndex === 0 && maxPageIndex === 0) {
            this.calculateReferenceValues();
        }
        this.setActivePage(targetPageIndex);
        this.setTargetsByPage(targetPageIndex);
        if (this.dynamicElements) {
            this.dynamicElementsPageChange(targetPageIndex);
        }
        this._currentMovement = Movement.NONE;
        if (maxPageIndex === 0) {
            TouchManager_1.default.instance.removeGesture(TouchManager_1.GESTURE.PAN);
        }
        const onEnd = () => {
            this._currentMovement = Movement.SWIPE;
            this.destroyElement(element, done);
        };
        if (transition) {
            transition(element, onEnd);
        }
        else {
            this.elementRemovalTransition(element, onEnd);
        }
        return element;
    }
    getPagesCount() {
        return Math.ceil(this.componentsTotal / this.elementsPerPage);
    }
    calculateReferenceValues() {
        if (this.autoFitElements) {
            const total = this.componentsTotal;
            if (total > 0) {
                let elementCount = 0;
                let hitLimit = false;
                while (!hitLimit) {
                    elementCount++;
                    if (elementCount > total || this.elementBuffer > (FaceRenderer_1.default.WIDTH - elementCount * this.elementDimensions.width) / (elementCount + 1)) {
                        elementCount--;
                        if (elementCount >= total) {
                            this.elementsPerPage = elementCount;
                            this.pageHinting = false;
                        }
                        hitLimit = true;
                    }
                }
            }
        }
        let width = FaceRenderer_1.default.WIDTH - ((this.pageHinting) ? (this.EDGE_HINT * 2) : 0);
        let calcBuffer = Math.max(this.elementBuffer, (width - this.elementsPerPage * this.elementDimensions.width) / (this.elementsPerPage + 1));
        this._listStartPosition = new PIXI.Point((FaceRenderer_1.default.WIDTH - this.elementsPerPage * this.elementDimensions.width - (this.elementsPerPage - 1) * calcBuffer) / 2, this.axisPosition - this.elementDimensions.height / 2);
        this._elementSpacing = +this.elementDimensions.width + calcBuffer;
        this._bufferMax = calcBuffer + this.BUFFER_SPREAD;
    }
    createComponentsFromConfigs(elementConfigs, defaultElementData) {
        let creator = ComponentCreator_1.default.instance;
        let numElements = elementConfigs.length;
        let i = 0;
        if (defaultElementData) {
            let elementConfig;
            for (; i < numElements; i++) {
                elementConfig = this.mergeConfigs(elementConfigs[i], defaultElementData);
                this.addComponent(creator.createComponentFromConfig(elementConfig));
            }
        }
        else {
            for (; i < numElements; i++) {
                this.addComponent(creator.createComponentFromConfig(elementConfigs[i]));
            }
        }
    }
    get assetDescriptors() {
        if (!this.dynamicElements) {
            return this.groupAssetDescriptors;
        }
        else {
            this._assetDescriptors = (this._assetDescriptors || []);
            this._assetDescriptors.push({
                id: 'loader',
                type: 'timeline',
                src: 'core://resources/buttons/loader.js'
            });
            let groupAssetDescriptors = (this._assetDescriptors) ? this._assetDescriptors.slice(0) : [];
            if (this.dynamicPreload && this.componentList) {
                this._pageIndex = this.normalizePageIndex(this._pageIndex);
                const endLoadIndex = Math.min(this.getStartIndexByPage(this.normalizePageIndex(this._pageIndex + this.dynamicLoadBuffer)) + +this.elementsPerPage, this.componentList.length);
                let i = this.getStartIndexByPage(this.normalizePageIndex(this._pageIndex - this.dynamicLoadBuffer));
                let component;
                let nextAssetDescriptors;
                for (i; i < endLoadIndex; i++) {
                    component = this.componentList[i];
                    nextAssetDescriptors = component.assetDescriptors;
                    if (nextAssetDescriptors) {
                        groupAssetDescriptors = groupAssetDescriptors.concat(nextAssetDescriptors);
                    }
                }
            }
            return groupAssetDescriptors;
        }
    }
    updateConfig(configData) {
        configData = configData || {};
        Object.assign(configData, { pageIndex: this._pageIndex, indexOfAction: this._indexOfAction });
        return super.updateConfig(configData);
    }
    createDisplay(container, assets) {
        this._assets = assets;
        this.container = container;
        this.calculateReferenceValues();
        this.setActivePage(this._pageIndex);
        const startIndex = this.getStartIndexByPage(this._pageIndex);
        if (!this.elementDimensions) {
            this.elementDimensions = { width: 330, height: 330 };
        }
        let element;
        let i;
        let listMember;
        let length = this.componentList.length;
        let indexDiff;
        for (i = 0; i < length; i++) {
            element = this.componentList[i];
            listMember = new ListMember_1.default();
            element.addSubcomponent(listMember);
            indexDiff = i - startIndex;
            element.setTargetPosition(this._listStartPosition.x + (this._elementSpacing * indexDiff), this._listStartPosition.y);
            if (!this.dynamicElements) {
                element.createDisplay(container, assets);
                listMember.loaded = true;
            }
            else {
                listMember.loaded = false;
                element.display = new PIXI.Container();
                element.applyPosition();
            }
            listMember.targetPosition = element.targetPosition.clone();
            listMember.velocity = new PIXI.Point(0, 0);
            listMember.targetOffset = 0;
        }
        if (this.dynamicElements) {
            this._loadingElements = [];
            if (this.dynamicPreload) {
                this.dynamicElementsPageChange(this._pageIndex);
            }
        }
    }
    ready() {
        if (this.componentList) {
            const length = this.componentList.length;
            if (this.dynamicElements && !this.dynamicPreload && length > 0) {
                this.dynamicElementsPageChange(this._pageIndex);
            }
            this.registerUpdate(true);
            if (!this.noPan) {
                this._leftPageBound = this._listStartPosition.x;
                this._rightPageBound = FaceRenderer_1.default.WIDTH - this._listStartPosition.x;
                this._requiresPan = true;
            }
        }
        super.ready();
    }
    destroy() {
        this.registerUpdate(false);
        TouchManager_1.default.instance.removeGesture(TouchManager_1.GESTURE.PAN);
        this._listStartPosition = null;
        this.defaultElementData = null;
        this.elementDimensions = null;
        super.destroy();
    }
    lockInput(flag) {
        if (this._requiresPan && !flag) {
            TouchManager_1.default.instance.addGesture(TouchManager_1.GESTURE.PAN, this.onPanEvent);
        }
        super.lockInput(flag);
    }
    lockChildInput(flag) {
        if (this._childInputLocked !== flag) {
            if (!this.dynamicElements) {
                super.lockChildInput(flag);
            }
            else {
                this._childInputLocked = flag;
                if (this.componentList) {
                    let i = this._dynamicActiveIndexRange[0];
                    const end = this._dynamicActiveIndexRange[1];
                    for (i; i < end; i++) {
                        this.componentList[i].lockInput(flag);
                    }
                }
            }
        }
    }
    open(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME, tweenType = 'backOut') {
        if (this.componentList.length > 0) {
            if (transitionType === ViewManager_1.TRANSITION.UP || transitionType === ViewManager_1.TRANSITION.DOWN) {
                this.openVertical(callback, transitionType, duration, tweenType);
            }
            else if (transitionType === ViewManager_1.TRANSITION.EYE) {
                this.openFromEye(callback, duration);
            }
            else {
                callback();
            }
        }
        else {
            callback();
        }
    }
    close(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME, tweenType = 'backIn') {
        if (this.componentList.length > 0) {
            if (transitionType === ViewManager_1.TRANSITION.UP || transitionType === ViewManager_1.TRANSITION.DOWN) {
                this.closeVertical(callback, transitionType, duration, tweenType);
            }
            else if (transitionType === ViewManager_1.TRANSITION.EYE) {
                this.closeToEye(callback, duration);
            }
            else {
                callback();
            }
        }
        else {
            callback();
        }
    }
    getElementsByPage(pageIndex = this._pageIndex) {
        const pageNormalized = this.normalizePageIndex(pageIndex);
        const startIndex = this.getStartIndexByPage(pageNormalized);
        const endIndex = Math.min(startIndex + this.elementsPerPage, this.componentsTotal);
        return this.componentList.slice(startIndex, endIndex);
    }
    actionHandler(action, fromComponent) {
        if (fromComponent) {
            const member = fromComponent.getSubcomponent(ListMember_1.default.TYPE);
            if (member) {
                const index = super.getIndexOfComponent(fromComponent);
                if (index > -1) {
                    this._indexOfAction = index;
                    this._stateChanged = true;
                    if (action.type === List.REMOVE_ELEMENT) {
                        this.removeComponent(fromComponent);
                    }
                }
            }
        }
        this.parentGroup.actionHandler(action);
    }
    actionEnactor(action) {
        let actionActedOn = false;
        switch (action.type) {
            case ActionData_1.default.SWIPE_RIGHT:
                {
                    this.changePage(false);
                    actionActedOn = true;
                    break;
                }
            case ActionData_1.default.SWIPE_LEFT:
                {
                    this.changePage(true);
                    actionActedOn = true;
                    break;
                }
            case ActionData_1.default.GO_TO_BEGINNING:
                {
                    this.pageToEnd(true);
                    actionActedOn = true;
                    break;
                }
            case ActionData_1.default.GO_TO_END:
                {
                    this.pageToEnd(false);
                    actionActedOn = true;
                    break;
                }
            case ActionData_1.default.VERBAL_COMMAND:
                {
                    if (action.data && action.data.intent) {
                        const intent = action.data.intent;
                        if (intent === 'right') {
                            this.changePage(true);
                            actionActedOn = true;
                        }
                        else if (intent === 'left') {
                            this.changePage(false);
                            actionActedOn = true;
                        }
                        else if (intent === 'beginning') {
                            this.pageToEnd(true);
                            actionActedOn = true;
                        }
                        else if (intent === 'end') {
                            this.pageToEnd(false);
                            actionActedOn = true;
                        }
                        else if (intent === 'selectItem') {
                            const startIndex = this.getStartIndexByPage(this.normalizePageIndex(this._pageIndex));
                            const endIndex = Math.min(startIndex + +this.elementsPerPage, this.componentsTotal);
                            const pageTotal = endIndex - startIndex;
                            let selectedElement;
                            if (action.data.entities.itemPosition) {
                                const itemPosition = action.data.entities.itemPosition;
                                let index;
                                if (pageTotal > 1) {
                                    if (itemPosition === 'first' || itemPosition === 'left') {
                                        selectedElement = this.componentList[startIndex];
                                    }
                                    else if (itemPosition === 'second') {
                                        selectedElement = this.componentList[startIndex + 1];
                                    }
                                    else if (itemPosition === 'third') {
                                        if (pageTotal > 2) {
                                            selectedElement = this.componentList[startIndex + 2];
                                        }
                                    }
                                    else if (itemPosition === 'fourth') {
                                        if (pageTotal > 3) {
                                            selectedElement = this.componentList[startIndex + 3];
                                        }
                                    }
                                    else if (itemPosition === 'middle') {
                                        if (pageTotal % 2 === 1) {
                                            index = Math.min(Math.floor(startIndex + this.elementsPerPage / 2), endIndex - 1);
                                            selectedElement = this.componentList[index];
                                        }
                                    }
                                    else if (itemPosition === 'right') {
                                        selectedElement = this.componentList[endIndex - 1];
                                    }
                                }
                                else if (pageTotal === 1) {
                                    if (itemPosition === 'first' || itemPosition === 'middle') {
                                        selectedElement = this.componentList[startIndex];
                                    }
                                }
                                else {
                                    log.info('actionEnactor() mim result action intent selectItem, list is empty, nothing to select.');
                                }
                            }
                            else {
                                if (pageTotal === 1) {
                                    selectedElement = this.componentList[startIndex];
                                }
                                else {
                                    log.info('actionEnactor() mim result action intent selectItem, must define itemPosition in data if more than one element in list.');
                                }
                            }
                            if (selectedElement) {
                                actionActedOn = true;
                                if (selectedElement instanceof Button_1.default) {
                                    selectedElement.activate();
                                }
                                selectedElement.triggerActions();
                            }
                        }
                    }
                    else {
                        log.info('actionEnactor() : mim result action define an intent with its data.');
                    }
                    break;
                }
            default:
                {
                    break;
                }
        }
        return actionActedOn;
    }
    update(elapsed) {
        if (this._currentMovement !== Movement.NONE) {
            this.springUpdate();
        }
    }
    changePage(pageForward = true) {
        if (this._axis === 'horizontal') {
            if (pageForward) {
                if (this._pageIndex < Math.ceil(this.componentList.length / this.elementsPerPage) - 1) {
                    this.setActivePage(this._pageIndex + 1);
                    this.setTargetsByPage(this._pageIndex);
                    if (this.dynamicElements) {
                        this.dynamicElementsPageChange(this.pageIndex);
                    }
                    this.actionHandler(new ActionData_1.default(List.PAGED), this);
                    this.actionHandler(new ActionData_1.default(ActionData_1.default.EVENT, { event: List.PAGED }));
                    Runtime_1.default.instance.sound.play('swipeLR');
                    return true;
                }
                else {
                    this.actionHandler(new ActionData_1.default(ActionData_1.default.EVENT, { event: List.AT_END }));
                    Runtime_1.default.instance.sound.play('swipeEoL');
                }
            }
            else {
                if (this._pageIndex !== 0) {
                    this.setActivePage(this._pageIndex - 1);
                    this.setTargetsByPage(this._pageIndex);
                    if (this.dynamicElements) {
                        this.dynamicElementsPageChange(this.pageIndex);
                    }
                    this.actionHandler(new ActionData_1.default(List.PAGED), this);
                    this.actionHandler(new ActionData_1.default(ActionData_1.default.EVENT, { event: List.PAGED }));
                    Runtime_1.default.instance.sound.play('swipeLR');
                    return true;
                }
                else {
                    this.actionHandler(new ActionData_1.default(ActionData_1.default.EVENT, { event: List.AT_FRONT }));
                    Runtime_1.default.instance.sound.play('swipeEoL');
                }
            }
        }
        else {
            log.info('changePage() : vertical lists are not currently supported.');
        }
        return false;
    }
    pageToEnd(pageToFront = false) {
        if (this._axis === 'horizontal') {
            if (!pageToFront) {
                if (this._pageIndex < Math.ceil(this.componentList.length / this.elementsPerPage) - 1) {
                    const maxIndex = Math.ceil(this.componentList.length / this.elementsPerPage) - 1;
                    this.setActivePage(maxIndex);
                    this.setTargetsByPage(maxIndex);
                    if (this.dynamicElements) {
                        this.dynamicElementsPageChange(this.pageIndex);
                    }
                    this.actionHandler(new ActionData_1.default(List.PAGED), this);
                    this.actionHandler(new ActionData_1.default(ActionData_1.default.EVENT, { event: List.PAGED }));
                    Runtime_1.default.instance.sound.play('swipeLR');
                    return true;
                }
                else {
                    this.actionHandler(new ActionData_1.default(ActionData_1.default.EVENT, { event: List.AT_END }));
                    Runtime_1.default.instance.sound.play('swipeEoL');
                }
            }
            else {
                if (this._pageIndex !== 0) {
                    this.setActivePage(0);
                    this.setTargetsByPage(0);
                    if (this.dynamicElements) {
                        this.dynamicElementsPageChange(this.pageIndex);
                    }
                    this.actionHandler(new ActionData_1.default(List.PAGED), this);
                    this.actionHandler(new ActionData_1.default(ActionData_1.default.EVENT, { event: List.PAGED }));
                    Runtime_1.default.instance.sound.play('swipeLR');
                    return true;
                }
                else {
                    this.actionHandler(new ActionData_1.default(ActionData_1.default.EVENT, { event: List.AT_FRONT }));
                    Runtime_1.default.instance.sound.play('swipeEoL');
                }
            }
        }
        else {
            log.info('pageToEnd() vertical lists are not currently supported.');
        }
        return false;
    }
    getStartIndexByPage(pageIndex) {
        if (pageIndex === 0) {
            return 0;
        }
        else {
            return pageIndex * this.elementsPerPage - this._pageElementOffset;
        }
    }
    setActivePage(pageIndex) {
        let index = this.normalizePageIndex(pageIndex);
        if (this._pageIndex !== index) {
            this._pageIndex = index;
            this._stateChanged = true;
        }
        const length = this.componentList.length;
        if (index === 0) {
            this._pageElementOffset = 0;
        }
        else {
            let startIndex = index * this.elementsPerPage;
            const endIndex = startIndex + this.elementsPerPage;
            if (endIndex > length) {
                this._pageElementOffset = endIndex - length;
            }
        }
        if (this.dynamicElements) {
            if (!this._dynamicActiveIndexRange) {
                this._dynamicActiveIndexRange = [0, 0];
            }
            this._dynamicActiveIndexRange[0] = this.getStartIndexByPage(this.normalizePageIndex(index - this.dynamicLoadBuffer));
            this._dynamicActiveIndexRange[1] = Math.min(this.getStartIndexByPage(this.normalizePageIndex(index + this.dynamicLoadBuffer)) + this.elementsPerPage, length);
        }
    }
    openVertical(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME, tweenType = 'backIn') {
        let startY = 0;
        if (transitionType === ViewManager_1.TRANSITION.UP) {
            startY = +FaceRenderer_1.default.HEIGHT + +this.elementDimensions.height;
        }
        else if (transitionType === ViewManager_1.TRANSITION.DOWN) {
            startY = -this.elementDimensions.height;
        }
        const startIndex = Math.max(this.getStartIndexByPage(this._pageIndex) - this.numElementsAtEdge, 0);
        const endIndex = Math.min(this.getStartIndexByPage(this._pageIndex) + +this.elementsPerPage + +this.numElementsAtEdge, this.componentList.length);
        const targetY = this.componentList[startIndex].targetPosition.y;
        let focusIndex = Math.max(this._indexOfAction - startIndex, 0);
        TweenManager_1.default.playSet(this.componentList.slice(startIndex, endIndex).map(function (element) {
            return element.display;
        }), {
            from: { y: startY },
            to: { y: targetY },
            ease: tweenType,
            duration: duration
        }, {
            focus: focusIndex,
            focusIsLast: false,
            delay: 100,
            complete: callback,
            completeOnFirst: true
        });
    }
    closeVertical(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME, tweenType = 'backIn') {
        const startIndex = Math.max(this.getStartIndexByPage(this._pageIndex) - this.numElementsAtEdge, 0);
        const endIndex = Math.min(this.getStartIndexByPage(this._pageIndex) + this.elementsPerPage + +this.numElementsAtEdge, this.componentList.length);
        let endY = 0;
        let focusIndex = 0;
        let focusIsLast = true;
        let delay = 100;
        if (transitionType === ViewManager_1.TRANSITION.UP) {
            endY = -this.elementDimensions.height;
            focusIndex = Math.max(this._indexOfAction - startIndex, 0);
            focusIsLast = false;
        }
        else if (transitionType === ViewManager_1.TRANSITION.DOWN) {
            endY = +FaceRenderer_1.default.HEIGHT + +this.elementDimensions.height;
            delay = 0;
        }
        TweenManager_1.default.playSet(this.componentList.slice(startIndex, endIndex).map(function (element) { return element.display; }), {
            to: { y: endY },
            ease: tweenType,
            duration: duration
        }, {
            focus: focusIndex,
            focusIsLast: focusIsLast,
            delay: delay,
            complete: callback
        });
    }
    openFromEye(callback, duration = ViewManager_1.default.TRANS_TIME) {
        if (this.componentList.length > 0) {
            const startIndex = Math.max(this.getStartIndexByPage(this.pageIndex) - this.numElementsAtEdge, 0);
            const endIndex = Math.min(this.getStartIndexByPage(this.pageIndex) + +this.elementsPerPage + +this.numElementsAtEdge, this.componentList.length);
            const elementDisplays = this.componentList.slice(startIndex, endIndex).map(function (element) {
                return element.display;
            });
            const targetY = this.componentList[startIndex].targetPosition.y;
            for (let i = 0; i < elementDisplays.length; i++) {
                elementDisplays[i].y = targetY;
            }
            const eyeDiameter = 450;
            const targetScale = DisplayUtils_1.default.getScaleByWidthHeight(elementDisplays[0], eyeDiameter, eyeDiameter);
            const startX = FaceRenderer_1.default.WIDTH / 2 - eyeDiameter / 2;
            const startY = FaceRenderer_1.default.HEIGHT / 2 - eyeDiameter / 2;
            TweenManager_1.default.playSet(elementDisplays, {
                from: {
                    x: startX,
                    y: startY,
                    'scale.x': targetScale,
                    'scale.y': targetScale
                },
                ease: 'backOut',
                duration: duration
            }, {
                complete: callback
            });
        }
        else {
            callback();
        }
    }
    closeToEye(callback, duration = ViewManager_1.default.TRANS_TIME) {
        if (this.componentList.length > 0) {
            const startIndex = Math.max(this.getStartIndexByPage(this.pageIndex) - this.numElementsAtEdge, 0);
            const endIndex = Math.min(this.getStartIndexByPage(this.pageIndex) + this.elementsPerPage + +this.numElementsAtEdge, this.componentList.length);
            const elementDisplays = this.componentList.slice(startIndex, endIndex).map(function (element) {
                return element.display;
            });
            const eyeDiameter = 450;
            const targetX = FaceRenderer_1.default.WIDTH / 2 - eyeDiameter / 2;
            const targetY = FaceRenderer_1.default.HEIGHT / 2 - eyeDiameter / 2;
            let targetScale = DisplayUtils_1.default.getScaleByWidthHeight(elementDisplays[0], eyeDiameter, eyeDiameter);
            TweenManager_1.default.playSet(elementDisplays, {
                to: {
                    x: targetX,
                    y: targetY,
                    'scale.x': targetScale,
                    'scale.y': targetScale
                },
                ease: 'backIn',
                duration: duration
            }, {
                complete: callback
            });
        }
        else {
            callback();
        }
    }
    dynamicElementsPageChange(pageIndex) {
        const startLoadIndex = this._dynamicActiveIndexRange[0];
        const endLoadIndex = this._dynamicActiveIndexRange[1];
        let assetsToLoad;
        let assetsToRemove;
        let element;
        let i;
        let j;
        let asset;
        const length = this.componentList.length;
        for (i = 0; i < length; i++) {
            if (i < startLoadIndex || i >= endLoadIndex) {
                element = this.componentList[i];
                if (element.getSubcomponent(ListMember_1.default.TYPE).loaded) {
                    this.emptyElementDisplay(element);
                    this.container.removeChild(element.display);
                    for (j = 0; j < element.assetDescriptors.length; j++) {
                        asset = element.assetDescriptors[j];
                        if (this._assets[asset.id]) {
                            if (!assetsToRemove) {
                                assetsToRemove = {};
                            }
                            assetsToRemove[asset.id] = asset;
                        }
                    }
                }
            }
            else {
                i = endLoadIndex - 1;
            }
        }
        let requiresLoad;
        for (i = startLoadIndex; i < endLoadIndex; i++) {
            element = this.componentList[i];
            if (element.assetDescriptors) {
                if (element.getSubcomponent(ListMember_1.default.TYPE).loaded) {
                    if (assetsToRemove) {
                        for (j = 0; j < element.assetDescriptors.length; j++) {
                            asset = element.assetDescriptors[j];
                            if (assetsToRemove[asset.id]) {
                                delete assetsToRemove[asset.id];
                            }
                        }
                    }
                }
                else {
                    requiresLoad = false;
                    for (j = 0; j < element.assetDescriptors.length; j++) {
                        asset = element.assetDescriptors[j];
                        if (assetsToRemove && assetsToRemove[asset.id]) {
                            delete assetsToRemove[asset.id];
                        }
                        if (!this._assets[asset.id]) {
                            requiresLoad = true;
                            if (!assetsToLoad) {
                                assetsToLoad = {};
                            }
                            assetsToLoad[asset.id] = asset;
                        }
                    }
                    if (!requiresLoad) {
                        this.updateElementDisplay(element);
                    }
                    else {
                        this._loadingElements.push(element);
                        const loaderClip = new this._assets['loader'].library.stage();
                        loaderClip.x += this.elementDimensions.width / 2;
                        loaderClip.y += this.elementDimensions.height / 2;
                        element.display.addChild(loaderClip);
                        if (!element.display.parent) {
                            this.container.addChild(element.display);
                        }
                    }
                }
            }
        }
        if (assetsToRemove) {
            this.parentView.removeAssets(assetsToRemove);
        }
        if (assetsToLoad) {
            this.parentView.addAssets(assetsToLoad, (err) => {
                if (err) {
                    log.warn('encountered error loading assets for list elements');
                    this.iterativeLoad(assetsToLoad);
                }
                else {
                    this.assignElementAssets();
                }
            });
        }
    }
    iterativeLoad(assetsToLoad) {
        for (let key in assetsToLoad) {
            if (assetsToLoad.hasOwnProperty(key)) {
                let asset = assetsToLoad[key];
                delete assetsToLoad[key];
                this.parentView.addAssets(asset, (err) => {
                    if (err) {
                        log.warn('encountered error loading asset', asset);
                    }
                    this.assignElementAssets();
                    this.iterativeLoad(assetsToLoad);
                });
                return;
            }
        }
    }
    assignElementAssets() {
        let element;
        let assetsFound;
        let i = this._loadingElements.length - 1;
        let j;
        for (i; i >= 0; i--) {
            assetsFound = true;
            element = this._loadingElements[i];
            for (j = element.assetDescriptors.length - 1; j >= 0 && assetsFound; j--) {
                if (!this._assets[element.assetDescriptors[j].id]) {
                    assetsFound = false;
                }
            }
            if (assetsFound) {
                this._loadingElements.splice(i, 1);
                this.updateElementDisplay(element);
            }
        }
    }
    updateElementDisplay(element) {
        this.emptyElementDisplay(element);
        element.setupDisplay(this._assets);
        if (!element.display.parent) {
            this.container.addChild(element.display);
        }
        element.getSubcomponent(ListMember_1.default.TYPE).loaded = true;
    }
    emptyElementDisplay(element) {
        element.getSubcomponent(ListMember_1.default.TYPE).loaded = false;
        element.emptyDisplay();
    }
    setTargetsByPage(pageIndex) {
        this._currentMovement = Movement.SWIPE;
        let pageStartX = this._listStartPosition.x - (this.getStartIndexByPage(pageIndex) * this._elementSpacing);
        this.lockChildInput(true);
        const length = this.componentList.length;
        let member;
        for (let i = 0; i < length; i++) {
            member = this.componentList[i].getSubcomponent(ListMember_1.default.TYPE);
            member.targetOffset = 0;
            member.targetPosition.x = (pageStartX + (i * this._elementSpacing));
        }
    }
    setTargetsByInput(panState, velocity, inputX) {
        const maxSpacing = +this.elementDimensions.width + this._bufferMax;
        const targetOffset = Math.min(1, Math.abs(velocity) / this.BUFFER_SPREAD) * this.PAN_SPREAD;
        let member;
        let element;
        let length = this.componentList.length;
        for (let i = 0; i < length; ++i) {
            if (panState === PanCase.CLAMP_LEFT) {
                member = this.componentList[i].getSubcomponent(ListMember_1.default.TYPE);
                member.targetPosition.x = +this._leftPageBound + +targetOffset + this._bufferMax + (maxSpacing * i);
            }
            else if (panState === PanCase.CLAMP_RIGHT) {
                member = this.componentList[length - 1 - i].getSubcomponent(ListMember_1.default.TYPE);
                member.targetPosition.x = this._rightPageBound - targetOffset - this._bufferMax - (maxSpacing * (i + 1));
            }
            else if (panState === PanCase.DYNAMIC) {
                element = this.componentList[i];
                member = element.getSubcomponent(ListMember_1.default.TYPE);
                member.targetOffset = targetOffset * ((element.display.toGlobal(element.display.position).x - inputX) / maxSpacing);
                member.targetPosition.x += velocity;
            }
        }
    }
    springUpdate() {
        let element;
        let member;
        let deltaX;
        let deltaXAbs;
        let springsComplete = true;
        let unlockInput = true;
        const length = this.componentList.length;
        for (let i = 0; i < length; ++i) {
            element = this.componentList[i];
            member = element.getSubcomponent(ListMember_1.default.TYPE);
            deltaX = (member.targetPosition.x + member.targetOffset) - element.display.x;
            deltaXAbs = Math.abs(deltaX);
            if (deltaXAbs > 1 || member.velocity.x > 1) {
                member.velocity.x += deltaX * this.SPRING;
                element.display.x += (member.velocity.x *= this.FRICTION);
                springsComplete = false;
            }
            else {
                member.velocity.x = 0;
                element.display.x = member.targetPosition.x + member.targetOffset;
            }
            if (unlockInput && deltaXAbs > this.SWIPE_THRESHOLD) {
                unlockInput = false;
            }
        }
        if (this._currentMovement === Movement.SWIPE) {
            if (springsComplete) {
                this._currentMovement = Movement.NONE;
                this.lockChildInput(false);
            }
            else if (unlockInput) {
                this.lockChildInput(false);
            }
        }
    }
    pan(inputX, velocity) {
        if (this._currentMovement !== Movement.PAN) {
            this._currentMovement = Movement.PAN;
            this.lockChildInput(true);
            this.actionHandler(new ActionData_1.default(List.PAN), this);
        }
        this._panTotalDelta += velocity;
        const firstElement = this.componentList[0];
        const lastElement = this.componentList[this.componentList.length - 1];
        let panState;
        if (Math.abs(velocity) >= this.REST_THRESHOLD) {
            if (velocity > 0 && firstElement.display.x >= +this._leftPageBound + +this._bufferMax) {
                panState = PanCase.CLAMP_LEFT;
            }
            else if (velocity < 0 && +lastElement.display.x + +this.elementDimensions.width <= this._rightPageBound - this._bufferMax) {
                panState = PanCase.CLAMP_RIGHT;
            }
            else {
                panState = PanCase.DYNAMIC;
            }
            this.setTargetsByInput(panState, velocity, inputX);
        }
    }
    panStop() {
        if (Math.abs(this._panTotalDelta) > this.PAN_THRESHOLD) {
            if (!this.changePage(this._panTotalDelta < 0)) {
                this.setTargetsByPage(this.pageIndex);
                this.actionHandler(new ActionData_1.default(List.PAGED), this);
            }
        }
        else {
            this.setTargetsByPage(this.pageIndex);
            this.actionHandler(new ActionData_1.default(List.PAGED), this);
        }
        this._panTotalDelta = 0;
    }
    onPanEvent(event) {
        if (!this.inputLocked) {
            if (event.isFinal) {
                this.checkPanEvent(false);
            }
            else {
                if (event.velocityX !== 0.0) {
                    this.checkPanEvent(true, event.pointers[0].x, event.srcEvent.movementX);
                }
            }
        }
    }
    checkPanEvent(active, inputX = 0, deltaX = 0) {
        if (active) {
            this.pan(inputX, deltaX);
        }
        else if (this._currentMovement === Movement.PAN) {
            Runtime_1.default.instance.globalEvents.shared.screenGesture.emit(TouchManager_1.GESTURE.PAN);
            this.panStop();
        }
    }
    elementRemovalTransition(element, done) {
        const tweenTime = 200;
        const scaleEase = 'backIn';
        const fadeEase = 'sineIn';
        const display = element.display;
        element.centerPivot();
        TweenManager_1.default.play(display, {
            to: {
                'scale.x': 0,
                'scale.y': 0
            },
            duration: tweenTime,
            ease: scaleEase
        }, () => {
            TweenManager_1.default.stop(display);
            display.alpha = 0;
            display.pivot.x = 0;
            display.pivot.y = 0;
            display.x = 0;
            display.y = 0;
            done();
        });
        TweenManager_1.default.play(display, {
            to: { alpha: 0 },
            duration: tweenTime,
            ease: fadeEase
        });
    }
    destroyElement(element, done) {
        let startLoadIndex;
        let endLoadIndex;
        if (this.dynamicElements) {
            startLoadIndex = this.getStartIndexByPage(this.normalizePageIndex(this.pageIndex - this.dynamicLoadBuffer));
            endLoadIndex = Math.min(this.getStartIndexByPage(this.normalizePageIndex(this.pageIndex + this.dynamicLoadBuffer)) + +this.elementsPerPage, this.componentList.length);
        }
        else {
            startLoadIndex = 0;
            endLoadIndex = this.componentList.length;
        }
        let assetCount = element.assetDescriptors.length;
        if (assetCount > 0 && (!this.dynamicElements || element.getSubcomponent(ListMember_1.default.TYPE).loaded)) {
            let i;
            let assetsToRemove;
            let asset;
            for (i = 0; i < assetCount; i++) {
                asset = element.assetDescriptors[i];
                if (this._assets[asset.id]) {
                    if (!assetsToRemove) {
                        assetsToRemove = {};
                    }
                    assetsToRemove[asset.id] = asset;
                }
            }
            let loadedElement;
            let assetId;
            let j;
            mainLoop: for (i = startLoadIndex; i < endLoadIndex; i++) {
                loadedElement = this.componentList[i];
                if (loadedElement.assetDescriptors) {
                    if (!this.dynamicElements || loadedElement.getSubcomponent(ListMember_1.default.TYPE).loaded) {
                        for (j = 0; j < loadedElement.assetDescriptors.length; j++) {
                            assetId = loadedElement.assetDescriptors[j].id;
                            if (assetsToRemove[assetId]) {
                                delete assetsToRemove[assetId];
                                assetCount--;
                                if (assetCount === 0) {
                                    break mainLoop;
                                }
                            }
                        }
                    }
                }
            }
            if (assetCount > 0) {
                this.parentView.removeAssets(assetsToRemove);
            }
        }
        element.destroy();
        if (done) {
            done();
        }
    }
    mergeConfigs(data, defaultData, mergeArrays = true) {
        if (!mergeArrays) {
            return Object.assign({}, defaultData, data);
        }
        else {
            let output = {};
            let property;
            for (property in defaultData) {
                if (defaultData.hasOwnProperty(property)) {
                    if (!data.hasOwnProperty(property)) {
                        output[property] = defaultData[property];
                    }
                }
            }
            for (property in data) {
                if (data.hasOwnProperty(property)) {
                    if (Array.isArray(data[property]) && Array.isArray(defaultData[property])) {
                        if (property === 'colors') {
                            output[property] = data[property];
                        }
                        else if (property === 'assets') {
                            let defaultAssets = defaultData['assets'];
                            let outputAssets = data['assets'].slice(0);
                            let j = 0;
                            let outputLength = outputAssets.length;
                            let defaultAsset;
                            defaultLoop: for (let i = defaultAssets.length - 1; i >= 0; i--) {
                                defaultAsset = defaultAssets[i];
                                for (j = 0; j < outputLength; j++) {
                                    if (defaultAsset.id === outputAssets[j].id) {
                                        continue defaultLoop;
                                    }
                                }
                                outputAssets.push(defaultAsset);
                            }
                            output['assets'] = outputAssets;
                        }
                        else {
                            output[property] = data[property].concat(defaultData[property]);
                        }
                    }
                    else {
                        output[property] = data[property];
                    }
                }
            }
            return output;
        }
    }
    normalizePageIndex(pageIndex) {
        let page = pageIndex;
        if (page < 0) {
            page = 0;
        }
        else {
            let length = this.componentList.length;
            if (page * this.elementsPerPage > length) {
                page = Math.floor(length / this.elementsPerPage);
            }
        }
        return page;
    }
}
exports.default = List;

},{"../../../Runtime":1,"../../FaceRenderer":99,"../../tween/TweenManager":174,"../ComponentCreator":122,"../ComponentGroup":123,"../DisplayUtils":124,"../TouchManager":125,"../ViewManager":127,"../actions/ActionData":130,"../components/Button":132,"./log":144,"./subcomponents/ListMember":145}],140:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Element_1 = require("./Element");
const TweenManager_1 = require("../../tween/TweenManager");
const ViewManager_1 = require("../ViewManager");
const Runtime_1 = require("../../../Runtime");
class ListProgress extends Element_1.default {
    constructor() {
        super(...arguments);
        this._type = ListProgress.DEFAULT_TYPE;
        this._progressDisplay = null;
        this._backgroundDisplay = null;
        this._pageIndex = -1;
        this._pagesCount = -1;
        this._cornerRadius = 0;
    }
    static get DEFAULT_TYPE() { return 'ListProgress'; }
    assignConfig(configData) {
        super.assignConfig(configData);
        this._listProgressOptions = {
            width: ListProgress.DEFAULT_WIDTH,
            height: ListProgress.DEFAULT_HEIGHT,
            backgroundColor: ListProgress.BACKGROUND_COLOR,
            progressColor: ListProgress.PROGRESS_COLOR
        };
        Object.assign(this._listProgressOptions, configData || {});
        this._cornerRadius = this._listProgressOptions.height / 2;
        if (!this._targetPosition) {
            this._targetPosition = new PIXI.Point(this._listProgressOptions.position.x, this._listProgressOptions.position.y);
        }
    }
    setupDisplay(assets) {
        this._progressDisplay = new PIXI.Graphics();
        this._backgroundDisplay = new PIXI.Graphics();
        this.display.addChild(this._backgroundDisplay);
        this.display.addChild(this._progressDisplay);
        Runtime_1.default.instance.face.plugins.prepare.upload(this._backgroundDisplay);
        Runtime_1.default.instance.face.plugins.prepare.upload(this._progressDisplay);
    }
    updatePage(pageIndex = -1, pagesCount = -1) {
        if (this._pageIndex === -1 && pagesCount > 1) {
            this.drawBackground();
            this.drawProgress(this._listProgressOptions.width / pagesCount);
            this.open();
        }
        else {
            TweenManager_1.default.stop(this._progressDisplay);
            if (pagesCount === 1 && this._pagesCount > pagesCount) {
                this.close(() => {
                    this._pagesCount = -1;
                    this._pageIndex = -1;
                });
                return;
            }
            else if (pagesCount > 1) {
                const pageWidth = this._listProgressOptions.width / pagesCount;
                if (pagesCount !== this._pagesCount) {
                    this.drawProgress(pageWidth);
                }
                TweenManager_1.default.stop(this._progressDisplay);
                TweenManager_1.default.play(this._progressDisplay, {
                    to: {
                        x: pageWidth * pageIndex
                    },
                    duration: ViewManager_1.default.TRANS_TIME,
                    ease: 'cubicOut'
                });
            }
        }
        this._pageIndex = pageIndex;
        this._pagesCount = pagesCount;
    }
    getHeight() {
        return this._listProgressOptions.height;
    }
    open(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME, tweenType = 'sineOut') {
        TweenManager_1.default.stop(this.display);
        TweenManager_1.default.play(this.display, {
            to: { alpha: 1 },
            from: { alpha: 0 },
            duration: duration,
            ease: tweenType
        }, callback);
    }
    close(callback, transitionType, duration = ViewManager_1.default.TRANS_TIME, tweenType = 'sineIn') {
        TweenManager_1.default.stop(this.display);
        TweenManager_1.default.play(this.display, {
            to: { alpha: 0 },
            duration: duration,
            ease: tweenType
        }, callback);
    }
    destroy() {
        if (this._progressDisplay) {
            TweenManager_1.default.stop(this._progressDisplay);
            this._progressDisplay.destroy(true);
            this._progressDisplay = null;
        }
        if (this._backgroundDisplay) {
            this._backgroundDisplay.destroy(true);
            this._backgroundDisplay = null;
        }
        super.destroy();
    }
    drawBackground() {
        this._backgroundDisplay.clear();
        this._backgroundDisplay.lineStyle(0, this._listProgressOptions.backgroundColor);
        this._backgroundDisplay.beginFill(this._listProgressOptions.backgroundColor);
        this._backgroundDisplay.arc(this._cornerRadius, this._cornerRadius, this._cornerRadius, PIXI.DEG_TO_RAD * 90, PIXI.DEG_TO_RAD * 270);
        this._backgroundDisplay.drawRect(this._cornerRadius, 0, this._listProgressOptions.width - this._listProgressOptions.height, this._listProgressOptions.height);
        this._backgroundDisplay.arc(this._listProgressOptions.width - this._cornerRadius, this._cornerRadius, this._cornerRadius, PIXI.DEG_TO_RAD * 90, PIXI.DEG_TO_RAD * 270, true);
        this._backgroundDisplay.endFill();
    }
    drawProgress(pageWidth = 0) {
        this._progressDisplay.clear();
        this._progressDisplay.lineStyle(0, this._listProgressOptions.progressColor);
        this._progressDisplay.beginFill(this._listProgressOptions.progressColor);
        this._progressDisplay.arc(this._cornerRadius, this._cornerRadius, this._cornerRadius, PIXI.DEG_TO_RAD * 90, PIXI.DEG_TO_RAD * 270);
        this._progressDisplay.drawRect(this._cornerRadius, 0, pageWidth - this._listProgressOptions.height, this._listProgressOptions.height);
        this._progressDisplay.arc(pageWidth - this._cornerRadius, this._cornerRadius, this._cornerRadius, PIXI.DEG_TO_RAD * 90, PIXI.DEG_TO_RAD * 270, true);
        this._progressDisplay.endFill();
    }
}
ListProgress.DEFAULT_WIDTH = 1190;
ListProgress.DEFAULT_HEIGHT = 10;
ListProgress.BACKGROUND_COLOR = 0x21202b;
ListProgress.PROGRESS_COLOR = 0x37364a;
exports.default = ListProgress;

},{"../../../Runtime":1,"../../tween/TweenManager":174,"../ViewManager":127,"./Element":136}],141:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const StandardButton_1 = require("./StandardButton");
const Timeline_1 = require("../../animation/Timeline");
const TweenManager_1 = require("../../tween/TweenManager");
const ActionData_1 = require("../actions/ActionData");
const Runtime_1 = require("../../../Runtime");
const path = require("path");
const log_1 = require("./log");
const log = log_1.default.createChild('MenuButton');
exports.Colors = {
    DEFAULT: 'default',
    CONFIRM: 'confirm',
    CANCEL: 'cancel'
};
const DEFAULT_COLORS = {
    [exports.Colors.DEFAULT]: [0x25F2FB, 0x107799],
    [exports.Colors.CONFIRM]: [0xA3FF4A, 0x2A7922],
    [exports.Colors.CANCEL]: [0xFD362F, 0x990024]
};
class MenuButton extends StandardButton_1.default {
    constructor() {
        super(...arguments);
        this._type = MenuButton.SKILL;
        this.label = '';
        this.timelineId = '';
        this.iconMovieClip = null;
        this.iconId = '';
        this._dimensions = null;
        this._colors = null;
        this._buttonDatas = {
            [MenuButton.SKILL]: {
                assetPath: 'core://resources/buttons/skillButton.js',
                dimensions: { width: 330, height: 300 }
            },
            [MenuButton.ACTION]: {
                assetPath: 'core://resources/buttons/actionButton.js',
                dimensions: { width: 264, height: 264 }
            },
            [MenuButton.ACTION_BIG]: {
                assetPath: 'core://resources/buttons/bigActionButton.js',
                dimensions: { width: 330, height: 330 }
            }
        };
    }
    static get DEFAULT_TYPE() { return 'SkillButton'; }
    static get SKILL() { return 'SkillButton'; }
    static get ACTION() { return 'ActionButton'; }
    static get ACTION_BIG() { return 'ActionBigButton'; }
    get dimensions() {
        return this._dimensions;
    }
    static createFromConfig(configData) {
        let btn = new MenuButton();
        btn.assignConfig(configData);
        return btn;
    }
    get colors() { return this._colors; }
    set colors(value) {
        if (typeof value === 'string') {
            this._colors = DEFAULT_COLORS[value];
        }
        else {
            this._colors = value;
        }
        if (!this._colors) {
            this._colors = DEFAULT_COLORS[exports.Colors.DEFAULT];
        }
        this.applyColors();
    }
    getButtonData(type) {
        return this._buttonDatas[type];
    }
    addButtonData(type, assetPath, dimensions, cache) {
        const buttonData = {
            assetPath: assetPath,
            dimensions: dimensions,
            cache: cache
        };
        this._buttonDatas[type] = buttonData;
        return buttonData;
    }
    assignConfig(configData) {
        if (configData) {
            super.assignConfig(configData);
            if (configData.hasOwnProperty('colors')) {
                this.colors = configData.colors;
            }
            if (configData.hasOwnProperty('label')) {
                this.label = configData.label;
            }
            if (configData.iconSrc) {
                this.iconId = configData.iconSrc;
                if (this.iconId.endsWith(".js")) {
                    this.addAssetDescriptor(this.iconId, configData.iconSrc, 'timeline', true);
                }
                else {
                    this.addAssetDescriptor(this.iconId, configData.iconSrc, 'texture');
                }
            }
            let assetDescriptor;
            let descriptorClone;
            for (let i = 0; this._assetDescriptors && i < this._assetDescriptors.length; i++) {
                assetDescriptor = this._assetDescriptors[i];
                if (assetDescriptor.id === 'icon') {
                    this.iconId = assetDescriptor.src;
                    descriptorClone = JSON.parse(JSON.stringify(this._assetDescriptors[i]));
                    descriptorClone.id = this.iconId;
                    this._assetDescriptors[i] = descriptorClone;
                }
            }
        }
        this.applyButtonType();
    }
    applyButtonType(type) {
        if (type) {
            this._type = type;
        }
        const buttonData = this._buttonDatas[this._type];
        const src = buttonData.assetPath;
        this.timelineId = path.parse(src).name;
        super.addAssetDescriptorObject({
            id: this.timelineId,
            src: src,
            type: 'timeline',
            cache: buttonData.cache
        });
        this._dimensions = buttonData.dimensions;
        this.addAction(ActionData_1.default.SOUND, { id: 'button' }, false, true);
    }
    setupDisplay(assets) {
        this.setupTimeline(assets);
        this.setupHitArea();
        this.setupInteractions();
    }
    setupTimeline(assets) {
        if (assets.hasOwnProperty(this.timelineId)) {
            let movieClip = new assets[this.timelineId].library.stage();
            this._content = movieClip['content'];
            if (this._content) {
                this.applyColors();
                if (assets.hasOwnProperty(this.iconId)) {
                    if (assets[this.iconId] instanceof Timeline_1.default) {
                        this.iconMovieClip = assets[this.iconId].instance;
                        if (!this.iconMovieClip) {
                            this.iconMovieClip = new assets[this.iconId].library.stage();
                            Runtime_1.default.instance.face.plugins.prepare.upload(this.iconMovieClip);
                        }
                        this.iconMovieClip.gotoAndStop(0);
                        this.setIcon(this.iconMovieClip);
                    }
                    else {
                        this.setIcon(new PIXI.Sprite(assets[this.iconId]));
                    }
                }
                else if (this.iconId) {
                    log.warn('createDisplay() icon with id of: ' + this.iconId + ' not found in assets.');
                }
                this.display.addChild(movieClip);
                Runtime_1.default.instance.face.plugins.prepare.upload(this._content);
            }
            else {
                log.warn('createDisplay() MovieClip with instance name content not found in timeline');
            }
        }
        else {
            log.warn('createDisplay() timeline asset of id ' + this.timelineId + ' not found in assets');
        }
    }
    setIcon(icon) {
        if (this._content) {
            const iconContainer = this._content['icon'];
            if (iconContainer) {
                super.addToContent(icon, iconContainer, true);
            }
        }
    }
    setupHitArea(bounds) {
        if (!bounds && !this._hitArea && this._dimensions) {
            bounds = new PIXI.Rectangle(0, 0, this._dimensions.width, this._dimensions.height);
        }
        super.setupHitArea(bounds);
    }
    destroy() {
        this._dimensions = null;
        this._colors = null;
        this._buttonDatas = null;
        if (this.iconMovieClip) {
            TweenManager_1.default.stop(this.iconMovieClip);
            this.iconMovieClip = null;
        }
        super.destroy();
    }
    applyColors() {
        if (this._content && this._colors) {
            if (this._content['background']) {
                this._content['background'].children[0].tint = this._colors[0];
            }
            if (this._content['gradient']) {
                this._content['gradient'].children[0].tint = this._colors[1];
            }
        }
    }
}
exports.default = MenuButton;

},{"../../../Runtime":1,"../../animation/Timeline":105,"../../tween/TweenManager":174,"../actions/ActionData":130,"./StandardButton":142,"./log":144,"path":undefined}],142:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Button_1 = require("./Button");
const TweenManager_1 = require("../../tween/TweenManager");
const Runtime_1 = require("../../../Runtime");
const async = require("async");
const log_1 = require("./log");
const log = log_1.default.createChild('StandardButton');
class StandardButton extends Button_1.default {
    constructor() {
        super(...arguments);
        this._type = StandardButton.DEFAULT_TYPE;
        this._content = null;
        this.downScale = .9;
        this.activateScale = 1.15;
        this.tweenTime = 300;
        this.willToggle = false;
        this.disableStateAnimations = false;
        this._toggledOn = false;
        this.toggleAnimate = () => { };
    }
    static get DEFAULT_TYPE() { return 'StandardButton'; }
    static createFromConfig(configData) {
        let btn = new StandardButton();
        btn.assignConfig(configData);
        return btn;
    }
    static createFromDisplayObject(displayObject, actionData, container = null) {
        let btn = new StandardButton();
        btn.display = new PIXI.Container();
        if (container) {
            container.addChild(btn.display);
        }
        else if (displayObject.parent) {
            displayObject.parent.addChild(btn.display);
        }
        if (actionData) {
            btn.addAction(actionData);
        }
        btn.setupHitArea();
        btn.setupInteractions();
        btn.display.addChild(displayObject);
        return btn;
    }
    get toggledOn() { return this._toggledOn; }
    get buttonDisplay() {
        return this._content;
    }
    assignConfig(configData) {
        if (configData) {
            super.assignConfig(configData);
            if (configData.hasOwnProperty('willToggle')) {
                this.willToggle = configData.willToggle;
            }
            if (configData.hasOwnProperty('toggledOn')) {
                this._toggledOn = configData.toggledOn;
            }
            if (configData.hasOwnProperty('toggleAnimate') && typeof configData.toggleAnimate === 'function') {
                this.toggleAnimate = configData.toggleAnimate;
            }
            if (configData.hasOwnProperty('disableStateAnimations')) {
                this.disableStateAnimations = configData.disableStateAnimations;
            }
        }
    }
    emptyDisplay() {
        if (this._content) {
            TweenManager_1.default.stop(this._content);
        }
        super.emptyDisplay();
    }
    setupDisplay(assets) {
        let asset;
        let assetDescriptor;
        this._content = new PIXI.Sprite();
        let hasTextureAsset = false;
        for (let i = 0; i < this._assetDescriptors.length; i++) {
            assetDescriptor = this._assetDescriptors[i];
            asset = assets[assetDescriptor.id];
            if (assetDescriptor.hasOwnProperty('type')) {
                switch (assetDescriptor.type) {
                    case 'texture':
                        hasTextureAsset = true;
                        let sprite = new PIXI.Sprite(asset);
                        this.addToContent(sprite, this._content);
                        break;
                    case 'timeline':
                        let movieClip = new asset.library.stage();
                        this.addToContent(movieClip, this._content);
                        if (assetDescriptor.upload) {
                            Runtime_1.default.instance.face.plugins.prepare.upload(movieClip);
                        }
                        break;
                    default:
                        log.debug('setupDisplay() will not setup for asset type: ' + asset.type);
                }
            }
            else {
                log.debug('Button :: assignAssets() no type given for asset: ' + asset + ', assuming bitmap');
                let sprite = PIXI.Sprite.from(asset);
                this.addToContent(sprite, this._content);
            }
        }
        if (hasTextureAsset) {
            const bounds = this._content.getBounds();
            this._content.x += bounds.width / 2;
            this._content.y += bounds.height / 2;
        }
        this.display.addChild(this._content);
        if (this.willToggle) {
            this.toggleAnimate(this._toggledOn, false);
        }
        this.setupHitArea();
        this.setupInteractions();
    }
    addToContent(asset, container, emptyContent = false) {
        container = (container) ? container : this._content;
        if (container) {
            if (emptyContent) {
                container.removeChildren();
            }
            if (asset instanceof PIXI.Sprite) {
                asset.anchor.x = 0.5;
                asset.anchor.y = 0.5;
            }
            container.addChild(asset);
        }
    }
    destroy() {
        if (this._content) {
            TweenManager_1.default.stop(this._content);
            this._content = null;
        }
        super.destroy();
    }
    toggle(toggleOn, animate = true) {
        this._toggledOn = toggleOn;
        this.toggleAnimate(this._toggledOn, animate);
    }
    activate() {
        TweenManager_1.default.stop(this._content);
        TweenManager_1.default.play(this._content, {
            to: {
                'scale.x': this.activateScale,
                'scale.y': this.activateScale
            },
            duration: this.tweenTime,
            ease: 'sineOut'
        }, () => {
            TweenManager_1.default.play(this._content, {
                to: {
                    'scale.x': 1,
                    'scale.y': 1
                },
                duration: this.tweenTime,
                ease: 'backOut'
            });
        });
    }
    out() {
        if (this.isDown) {
            this.isDown = false;
            this.executeAsyncTransitions([
                () => {
                    if (!this.disableStateAnimations) {
                        this.outTransition();
                    }
                },
                () => {
                    if (this.willToggle) {
                        this.toggleOutTransition();
                    }
                }
            ]);
        }
    }
    outTransition() {
        this.animateUp();
    }
    toggleOutTransition() {
        this.toggleAnimate(this._toggledOn, true);
    }
    down() {
        if (!this.isDown) {
            this.isDown = true;
            this.executeAsyncTransitions([
                () => {
                    if (!this.disableStateAnimations) {
                        this.downTransition();
                    }
                },
                () => {
                    if (this.willToggle) {
                        this.toggleDownTransition();
                    }
                }
            ]);
        }
    }
    downTransition() {
        this.animateDown();
    }
    toggleDownTransition() {
        this.toggleAnimate(!this._toggledOn, true);
    }
    up() {
        if (this.isDown) {
            this.isDown = false;
            this.executeAsyncTransitions([
                () => {
                    if (!this.disableStateAnimations) {
                        this.upTransition();
                    }
                },
                () => {
                    if (this.willToggle) {
                        this.toggleUpTransition();
                    }
                }
            ]);
        }
    }
    upTransition() {
        this.animateUp();
    }
    toggleUpTransition() {
        this.toggle(!this._toggledOn, true);
    }
    animateDown() {
        TweenManager_1.default.stop(this._content);
        TweenManager_1.default.play(this._content, {
            to: {
                'scale.x': this.downScale,
                'scale.y': this.downScale
            },
            duration: this.tweenTime,
            ease: 'backOut'
        });
    }
    animateUp() {
        TweenManager_1.default.stop(this._content);
        TweenManager_1.default.play(this._content, {
            to: {
                'scale.x': 1,
                'scale.y': 1
            },
            duration: this.tweenTime / 2,
            ease: 'backOut'
        });
    }
    executeAsyncTransitions(transitionArray, callback) {
        async.parallel(transitionArray, function (err, results) {
            if (err) {
                log.error('Transitions encountered error', err);
            }
            this.transitionComplete(callback, err, results);
        }.bind(this));
    }
}
exports.default = StandardButton;

},{"../../../Runtime":1,"../../tween/TweenManager":174,"./Button":132,"./log":144,"async":undefined}],143:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Button_1 = require("./Button");
const StandardButton_1 = require("./StandardButton");
const Clip_1 = require("./Clip");
const ContactButton_1 = require("./ContactButton");
const ContentButton_1 = require("./ContentButton");
const Element_1 = require("./Element");
const ElementGroup_1 = require("./ElementGroup");
const Label_1 = require("./Label");
const List_1 = require("./List");
const ListProgress_1 = require("./ListProgress");
const MenuButton_1 = require("./MenuButton");
exports.default = {
    Button: Button_1.default,
    StandardButton: StandardButton_1.default,
    Clip: Clip_1.default,
    ContactButton: ContactButton_1.default,
    ContentButton: ContentButton_1.default,
    Element: Element_1.default,
    ElementGroup: ElementGroup_1.default,
    Label: Label_1.default,
    List: List_1.default,
    ListProgress: ListProgress_1.default,
    MenuButton: MenuButton_1.default
};

},{"./Button":132,"./Clip":133,"./ContactButton":134,"./ContentButton":135,"./Element":136,"./ElementGroup":137,"./Label":138,"./List":139,"./ListProgress":140,"./MenuButton":141,"./StandardButton":142}],144:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log_1 = require("../log");
const log = log_1.default.createChild('Components');
exports.default = log;

},{"../log":149}],145:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Subcomponent_1 = require("./Subcomponent");
class ListMember extends Subcomponent_1.default {
    constructor() {
        super(ListMember.TYPE);
        this.targetPosition = null;
        this.velocity = null;
        this.targetOffset = null;
        this.loaded = false;
    }
    static get TYPE() { return 'ListMember'; }
}
exports.default = ListMember;

},{"./Subcomponent":146}],146:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class Subcomponent {
    constructor(type) {
        this.component = null;
        this._type = type;
    }
    static get TYPE() { return 'TouchInteractive'; }
    get type() { return this._type; }
    init(component) {
        this.component = component;
    }
    destroy() {
        if (this.component) {
            this.component = null;
        }
    }
}
exports.default = Subcomponent;

},{}],147:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../../../../Runtime");
const TouchManager_1 = require("../../TouchManager");
const Subcomponent_1 = require("./Subcomponent");
class TouchInteractive extends Subcomponent_1.default {
    constructor() {
        super(TouchInteractive.TYPE);
        this.isActive = false;
        this._gestureActions = null;
        this._gestureActions = {};
    }
    static get TYPE() { return 'TouchInteractive'; }
    destroy() {
        super.destroy();
        this._gestureActions = null;
    }
    addAction(actionData, clearPrevious = false, toFront = false, gesture = TouchManager_1.GESTURE.TAP) {
        if (!this._gestureActions[gesture]) {
            this._gestureActions[gesture] = [];
        }
        else if (clearPrevious) {
            this._gestureActions[gesture].length = 0;
        }
        if (toFront) {
            this._gestureActions[gesture].unshift(actionData);
        }
        else {
            this._gestureActions[gesture].push(actionData);
        }
        TouchManager_1.default.instance.addGesture(gesture);
        return actionData;
    }
    hasActions(gesture = TouchManager_1.GESTURE.TAP) {
        return (this._gestureActions[gesture] && this._gestureActions[gesture].length > 0);
    }
    getActions(gesture = TouchManager_1.GESTURE.TAP) {
        return this._gestureActions[gesture];
    }
    clearActions(gesture = TouchManager_1.GESTURE.TAP) {
        delete this._gestureActions[gesture];
    }
    triggerActions(gesture = TouchManager_1.GESTURE.TAP) {
        let length = 0;
        if (this._gestureActions[gesture]) {
            if (this.component.parentGroup) {
                const actions = this._gestureActions[gesture];
                length = actions.length;
                for (let i = 0; i < length; i++) {
                    this.component.parentGroup.actionHandler(actions[i], this.component);
                }
            }
            else if (this.component instanceof Runtime_1.default.instance.face.views.View) {
                const actions = this._gestureActions[gesture];
                length = actions.length;
                for (let i = 0; i < length; i++) {
                    this.component.actionHandler(actions[i], this.component);
                }
            }
        }
        return length > 0;
    }
}
exports.default = TouchInteractive;

},{"../../../../Runtime":1,"../../TouchManager":125,"./Subcomponent":146}],148:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const ViewManager_1 = require("./ViewManager");
const ViewProcess_1 = require("./ViewProcess");
const ViewState_1 = require("./ViewState");
const ComponentCreator_1 = require("./ComponentCreator");
const components_1 = require("./components");
const views_1 = require("./views");
const actions_1 = require("./actions");
const TouchManager_1 = require("./TouchManager");
exports.default = {
    ViewManager: ViewManager_1.default,
    TRANSITION: ViewManager_1.TRANSITION,
    ViewProcess: ViewProcess_1.default,
    ViewState: ViewState_1.default,
    ComponentCreator: ComponentCreator_1.default,
    components: components_1.default,
    views: views_1.default,
    actions: actions_1.default,
    TouchManager: TouchManager_1.default,
    GESTURE: TouchManager_1.GESTURE
};

},{"./ComponentCreator":122,"./TouchManager":125,"./ViewManager":127,"./ViewProcess":128,"./ViewState":129,"./actions":131,"./components":143,"./views":157}],149:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log_1 = require("../../log");
exports.default = log_1.default.createChild('GUI');

},{"../../log":75}],150:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../../../Runtime");
const MenuView_1 = require("./MenuView");
const ContactButton_1 = require("../components/ContactButton");
const MenuButton_1 = require("../components/MenuButton");
const ActionData_1 = require("../actions/ActionData");
const View_1 = require("./View");
const log_1 = require("./log");
const log = log_1.default.createChild('ContatcsView');
class ContactsView extends MenuView_1.default {
    constructor() {
        super(...arguments);
        this.sortLoopList = null;
        this.determineCheck = null;
        this._type = ContactsView.DEFAULT_TYPE;
        this.showNotALoopMemberButton = false;
        this._loopMembers = null;
    }
    static get DEFAULT_TYPE() { return 'ContactsView'; }
    applyData() {
        if (this._viewConfig) {
            if (typeof this._viewConfig.sortLoopList === 'function') {
                this.sortLoopList = this._viewConfig.sortLoopList;
            }
            if (this._viewConfig.hasOwnProperty('showNotALoopMemberButton')) {
                this.showNotALoopMemberButton = this._viewConfig.showNotALoopMemberButton;
            }
        }
        super.applyData();
    }
    destroy() {
        this._loopMembers = null;
        this.sortLoopList = null;
        this.showNotALoopMemberButton = false;
        this.determineCheck = null;
        super.destroy();
    }
    loadData(loadAssetsOnComplete = true) {
        if (!this._loopMembers) {
            Runtime_1.default.instance.kb.loop.loadLoop((err, loop) => {
                if (err) {
                    log.error('loadData() : kb.loop.loadLoop return an error', err);
                    this.emit(View_1.STATE.LOAD_ERROR);
                    return;
                }
                if (loop) {
                    this._loopMembers = loop;
                    super.loadData(loadAssetsOnComplete);
                }
                else {
                    log.error('loadData() : kb.loop.loadLoop return loop as null');
                    this.emit(View_1.STATE.LOAD_ERROR);
                    return;
                }
            });
        }
        else {
            super.loadData(loadAssetsOnComplete);
        }
    }
    createListComponents(list) {
        if (this.showNotALoopMemberButton) {
            const notInLoopButton = MenuButton_1.default.createFromConfig({
                type: MenuButton_1.default.ACTION_BIG,
                id: 'notInLoop',
                label: 'Not a Loop\nMember',
                colors: MenuButton_1.Colors.DEFAULT,
                iconSrc: 'core://resources/actionIcons/not-in-loop.png',
                action: {
                    type: ActionData_1.default.UTTERANCE,
                    data: {
                        utterance: 'notInLoop'
                    }
                }
            });
            list.addComponent(notInLoopButton);
        }
        if (this._loopMembers) {
            let loopList = this._loopMembers;
            if (!this.sortLoopList) {
                this.sortLoopList = this.removeInvalidLoopers;
            }
            loopList = this.sortLoopList(loopList);
            let willToggle = false;
            if (this._viewConfig && this._viewConfig.hasOwnProperty('listDefault')) {
                if (this._viewConfig.listDefault.hasOwnProperty('willToggle')) {
                    willToggle = this._viewConfig.listDefault.willToggle;
                }
            }
            const length = loopList.length;
            let contactButton;
            let looper;
            let i;
            for (i = 0; i < length; i++) {
                looper = loopList[i];
                contactButton = new ContactButton_1.default();
                contactButton.assignLooper(looper);
                if (this.determineCheck) {
                    contactButton.toggle(this.determineCheck(looper));
                }
                contactButton.willToggle = willToggle;
                contactButton.applyButtonType();
                list.addComponent(contactButton);
            }
        }
    }
    removeInvalidLoopers(loopList) {
        if (loopList) {
            const length = loopList.length;
            let i = length - 1;
            for (i; i >= 0; i--) {
                if (loopList[i].isJibo || !loopList[i].data.hasOwnProperty('firstName')) {
                    loopList.splice(i, 1);
                }
            }
        }
        return loopList;
    }
}
exports.default = ContactsView;

},{"../../../Runtime":1,"../actions/ActionData":130,"../components/ContactButton":134,"../components/MenuButton":141,"./MenuView":153,"./View":156,"./log":158}],151:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const View_1 = require("./View");
const ViewManager_1 = require("../ViewManager");
const Runtime_1 = require("../../../Runtime");
class EyeView extends View_1.default {
    constructor() {
        super();
        this._type = EyeView.DEFAULT_TYPE;
        this.id = 'eyeView';
        this.soundSet = 'main';
        this._category = View_1.CATEGORY.EYE;
        this.borderNeeded = false;
        this.closeOnSwipeDown = false;
    }
    static get DEFAULT_TYPE() { return 'EyeView'; }
    open(callback, transitionType) {
        if (transitionType !== ViewManager_1.TRANSITION.NONE) {
            transitionType = ViewManager_1.TRANSITION.IN;
        }
        this._showEye();
        super.open(callback, transitionType);
    }
    pause(flag = true, pauseOptions) {
        super.pause(flag, pauseOptions);
        if (!flag) {
            this._showEye();
        }
    }
    close(callback, transitionType) {
        if (transitionType !== ViewManager_1.TRANSITION.NONE) {
            transitionType = ViewManager_1.TRANSITION.OUT;
        }
        super.close(callback, transitionType);
    }
    _showEye() {
        const eye = Runtime_1.default.instance.face.eye;
        this.stage.addChild(eye);
        eye.active = true;
    }
}
exports.default = EyeView;

},{"../../../Runtime":1,"../ViewManager":127,"./View":156}],152:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const View_1 = require("./View");
const Clip_1 = require("../components/Clip");
const FaceRenderer_1 = require("../../FaceRenderer");
const Runtime_1 = require("../../../Runtime");
class ImageView extends View_1.default {
    constructor() {
        super();
        this.scaleToFit = true;
        this._type = ImageView.DEFAULT_TYPE;
        this._clip = null;
    }
    static get DEFAULT_TYPE() { return 'ImageView'; }
    get clip() {
        return this._clip;
    }
    assignConfig(viewConfig) {
        if (viewConfig) {
            super.assignConfig(viewConfig);
            if (viewConfig['scaleToFit']) {
                this.scaleToFit = viewConfig['scaleToFit'];
            }
            if (viewConfig['image']) {
                this.imageDescriptor = viewConfig['image'];
            }
        }
    }
    applyData() {
        this._clip = new Clip_1.default();
        if (this.imageDescriptor) {
            this._clip.addAssetDescriptorObject(this.imageDescriptor);
        }
        this.addComponent(this._clip);
    }
    loaded() {
        super.createDisplay(this._stage, this._assets);
        this.positionClip();
        Runtime_1.default.instance.face.plugins.prepare.upload(this.ready.bind(this));
    }
    destroy() {
        this._clip = null;
        super.destroy();
    }
    positionClip() {
        let xCoord = FaceRenderer_1.default.WIDTH / 2;
        let yCoord = FaceRenderer_1.default.HEIGHT / 2;
        let display = this._clip.display;
        let ratio = display.width / display.height;
        let screenRatio = FaceRenderer_1.default.WIDTH / FaceRenderer_1.default.HEIGHT;
        let width;
        let height;
        if (display.width > FaceRenderer_1.default.WIDTH || display.height > FaceRenderer_1.default.HEIGHT) {
            if (display.width > FaceRenderer_1.default.WIDTH) {
                width = FaceRenderer_1.default.WIDTH;
                height = width / ratio;
            }
            if (display.height > FaceRenderer_1.default.HEIGHT) {
                height = FaceRenderer_1.default.HEIGHT;
                width = height * ratio;
            }
        }
        else {
            if (this.scaleToFit) {
                if (ratio > screenRatio) {
                    width = FaceRenderer_1.default.WIDTH;
                    height = width / ratio;
                }
                else {
                    height = FaceRenderer_1.default.HEIGHT;
                    width = height * ratio;
                }
            }
            else {
                width = display.width;
                height = display.height;
            }
        }
        xCoord -= width / 2;
        yCoord -= height / 2;
        let transformData = {
            scaleX: width / display.width,
            scaleY: height / display.height
        };
        this._clip.setTargetPosition(xCoord, yCoord);
        this._clip.setTransformData = transformData;
        this._clip.applyPosition();
    }
}
function isImageView(view) {
    return view instanceof ImageView;
}
exports.isImageView = isImageView;
exports.default = ImageView;

},{"../../../Runtime":1,"../../FaceRenderer":99,"../components/Clip":133,"./View":156}],153:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const View_1 = require("./View");
const Label_1 = require("../components/Label");
const MenuButton_1 = require("../components/MenuButton");
const List_1 = require("../components/List");
const ListProgress_1 = require("../components/ListProgress");
const FaceRenderer_1 = require("../../FaceRenderer");
const Runtime_1 = require("../../../Runtime");
const ViewManager_1 = require("../ViewManager");
const EyeView_1 = require("./EyeView");
const log_1 = require("./log");
const log = log_1.default.createChild('MenuView');
class MenuView extends View_1.default {
    constructor() {
        super(...arguments);
        this._type = MenuView.DEFAULT_TYPE;
        this._title = null;
        this._list = null;
        this._listProgress = null;
        this._buttonLabels = null;
    }
    static get DEFAULT_TYPE() { return 'MenuView'; }
    get list() {
        return this._list;
    }
    get titleLabel() {
        return this._title;
    }
    assignConfig(viewConfig) {
        if (viewConfig) {
            super.assignConfig(viewConfig);
            if (viewConfig['useEyeTransitions']) {
                this.addEyeTransitions();
            }
        }
    }
    applyData() {
        this._list = new List_1.default();
        this.addComponent(this._list);
        this.createListComponents(this._list);
        const menuButton = this._list.getComponentByIndex(0);
        const listConfig = (this._viewConfig) ? Object.assign({}, this._viewConfig) : {};
        listConfig.id = 'list';
        listConfig.type = List_1.default.DEFAULT_TYPE;
        if (!listConfig.elementsPerPage) {
            listConfig.elementsPerPage = 3;
        }
        if (!listConfig.elementDimensions && menuButton) {
            listConfig.elementDimensions = menuButton.dimensions;
        }
        delete listConfig.title;
        delete listConfig.assets;
        delete listConfig.list;
        if (this._viewConfig) {
            if (this._viewConfig.title) {
                this._title = new Label_1.default();
                this._title.id = 'title';
                this._title.text = this._viewConfig.title;
                this._title.style = Label_1.default.createFontStyle(100, 'Proxima Nova Soft', '#FFFFFF', 'bold');
                this._title.bounds = { width: FaceRenderer_1.default.WIDTH - (MenuView.TITLE_MARGIN * 2), height: MenuView.TITLE_HEIGHT };
                this.addComponent(this._title);
            }
            if (this._viewConfig.hasOwnProperty('progress') && this._viewConfig.progress) {
                this._listProgress = new ListProgress_1.default();
                this.addComponent(this._listProgress);
                let listProgressConfig = typeof this._viewConfig.progress === 'object' ? this._viewConfig.progress : {};
                if (!listProgressConfig.hasOwnProperty('position')) {
                    Object.assign(listProgressConfig, {
                        position: {
                            x: 'LEFT',
                            y: 'BOTTOM',
                            margin: {
                                x: MenuView.LISTPROGRESS_LEFT_MARGIN,
                                y: MenuView.LISTPROGRESS_BOTTOM_MARGIN
                            }
                        }
                    });
                }
                this._listProgress.assignConfig(listProgressConfig);
            }
        }
        this._list.assignConfig(listConfig);
        if (menuButton && menuButton.hasOwnProperty('label')) {
            this._buttonLabels = [];
            let buttonLabel;
            for (let i = 0; i < this._list.elementsPerPage; i++) {
                buttonLabel = new Label_1.default();
                buttonLabel.id = 'buttonLabel' + i;
                buttonLabel.style = Label_1.default.createFontStyle(50, 'Proxima Nova Light', '#FFFFFF', '', 'center');
                buttonLabel.bounds = { width: listConfig.elementDimensions.width, height: MenuView.LABEL_HEIGHT };
                this.addComponent(buttonLabel);
                this._buttonLabels.push(buttonLabel);
            }
        }
    }
    createListComponents(list) {
        if (this._viewConfig) {
            const defaultElementData = this._viewConfig.listDefault || {};
            const componentType = defaultElementData.menuButtonType || MenuButton_1.default.ACTION;
            if (!defaultElementData.type) {
                defaultElementData.type = componentType;
            }
            list.createComponentsFromConfigs(this._viewConfig.list, defaultElementData);
        }
        else {
            log.warn('createListComponents() this._viewConfig was not defined, but is required.');
        }
    }
    addEyeTransitions() {
        this.addTransition(EyeView_1.default.DEFAULT_TYPE, true, this.openFromEye, ViewManager_1.TRANSITION.NONE);
        this.addTransition(EyeView_1.default.DEFAULT_TYPE, false, this.closeToEye, ViewManager_1.TRANSITION.NONE);
    }
    loaded() {
        this.positionComponents();
        super.createDisplay(this._stage, this._assets);
        if (this._listProgress) {
            this._listProgress.updatePage(this._list.pageIndex, this._list.getPagesCount());
        }
        this.updateButtonLabels(false, false);
        Runtime_1.default.instance.face.plugins.prepare.upload(this.ready.bind(this));
    }
    destroy() {
        this._title = null;
        this._list = null;
        this._listProgress = null;
        this._buttonLabels = null;
        super.destroy();
    }
    actionHandler(action, fromComponent) {
        if (!this._inputLocked) {
            switch (action.type) {
                case List_1.default.PAGED:
                    if (this._listProgress) {
                        this._listProgress.updatePage(this._list.pageIndex, this._list.getPagesCount());
                    }
                    this.updateButtonLabels();
                    return;
                case List_1.default.REMOVE_ELEMENT:
                    if (this._listProgress) {
                        this._listProgress.updatePage(this._list.pageIndex, this._list.getPagesCount());
                    }
                    this.updateButtonLabels(this._buttonLabels &&
                        (this._list.elementsPerPage < this._buttonLabels.length || (this._list.elementsPerPage === 1 && this._buttonLabels.length === 1)));
                    return;
                case List_1.default.PAN:
                    this.fadeOutButtonLabels();
                    return;
            }
            super.actionHandler(action, fromComponent);
        }
    }
    openFromEye(callback) {
        let i;
        const numChildren = this._stage.children.length;
        for (i = 0; i < numChildren; i++) {
            this._stage.children[i].visible = false;
        }
        const eye = Runtime_1.default.instance.face.eye;
        this._stage.addChild(eye);
        eye.active = false;
        eye.visible = true;
        const duration = ViewManager_1.default.TRANS_TIME * .7;
        super.transitionFadeOutTo(() => {
            this._stage.removeChild(eye);
            eye.active = false;
            for (i = 0; i < numChildren; i++) {
                this._stage.children[i].visible = true;
            }
            super.openChildren(callback, ViewManager_1.TRANSITION.EYE, ViewManager_1.default.TRANS_TIME * .5);
            this.updateButtonLabels(false, false);
        }, 1.1, .8, .6, duration);
    }
    closeToEye(callback) {
        const duration = ViewManager_1.default.TRANS_TIME * .7;
        log.info('closeToEye() duration: ' + duration);
        super.closeChildren(() => {
            log.info('closeToEye() children closed successfully, start eye transition');
            this.eyeOpenTransition(callback, duration);
        }, ViewManager_1.TRANSITION.EYE, ViewManager_1.default.TRANS_TIME * .5);
    }
    updateConfig(configObject) {
        if (this._list.stateChanged) {
            configObject = this._list.updateConfig(configObject);
        }
        return super.updateConfig(configObject);
    }
    positionComponents(overrideTitleHeight) {
        let titleTotalHeight = 0;
        const titleBuffer = this._listProgress ? MenuView.TITLE_BUFFER - 25 : MenuView.TITLE_BUFFER;
        if (overrideTitleHeight) {
            titleTotalHeight = overrideTitleHeight + titleBuffer;
        }
        else if (this._title) {
            titleTotalHeight = +this._title.getTextDimensions('Flat').height + titleBuffer;
        }
        let menuLabelTotalHeight = 0;
        if (this._buttonLabels) {
            menuLabelTotalHeight = +this._buttonLabels[0].getTextDimensions('Flat').height / 2 + MenuView.MENU_LABEL_BUFFER;
        }
        const groupBuffer = (FaceRenderer_1.default.HEIGHT - (+titleTotalHeight + +this._list.elementDimensions.height + +menuLabelTotalHeight)) / 2;
        if (this._title) {
            this._title.setTargetPosition(FaceRenderer_1.default.WIDTH / 2, groupBuffer);
            this._title.setTargetAnchor(.5, 0);
        }
        this._list.axisPosition = +groupBuffer + +titleTotalHeight + (this._list.elementDimensions.height / 2);
        if (this._listProgress) {
            this._listProgress.targetPosition.y -= this._listProgress.getHeight();
        }
        this.positionButtonLabels();
    }
    positionButtonLabels() {
        if (this._buttonLabels) {
            const buttonLabelY = this._list.axisPosition + this._list.elementDimensions.height / 2 + MenuView.MENU_LABEL_BUFFER;
            let buttonLabel;
            for (let i = 0; i < this._buttonLabels.length; i++) {
                buttonLabel = this._buttonLabels[i];
                buttonLabel.setTargetPosition(+this._list.listStartPosition.x + (i * this._list.elementSpacing) + this._list.elementDimensions.width / 2, buttonLabelY, true);
                buttonLabel.setTargetAnchor(.5, .5);
            }
        }
    }
    updateButtonLabels(labelRemovalNeeded = false, playTransition = true, duration = 200) {
        if (!this._buttonLabels) {
            return;
        }
        if (labelRemovalNeeded) {
            let component = this.removeComponent(this._buttonLabels.pop());
            if (component) {
                component.destroy();
                component = null;
            }
        }
        this.positionButtonLabels();
        const buttonComponents = this._list.getElementsByPage();
        const length = buttonComponents.length;
        if (playTransition) {
            for (let i = 0; i < length; i++) {
                let menuBtn = buttonComponents[i];
                let buttonLabel = this._buttonLabels[i];
                if (buttonLabel.text !== menuBtn.label) {
                    if (buttonLabel.display.alpha === 1) {
                        buttonLabel.close(() => {
                            buttonLabel.text = menuBtn.label;
                            buttonLabel.open(null, null, duration);
                        }, null, duration);
                    }
                    else {
                        buttonLabel.text = menuBtn.label;
                        buttonLabel.open(null, null, duration);
                    }
                }
                else if (buttonLabel.display.alpha < 1) {
                    buttonLabel.open(null, null, duration);
                }
            }
        }
        else {
            for (let i = 0; i < length; i++) {
                this._buttonLabels[i].text = buttonComponents[i].label;
            }
        }
    }
    fadeOutButtonLabels(duration = 100) {
        if (!this._buttonLabels) {
            return;
        }
        const buttonComponents = this._list.getElementsByPage();
        const length = buttonComponents.length;
        for (let i = 0; i < length; i++) {
            let buttonLabel = this._buttonLabels[i];
            buttonLabel.close(null, null, duration, 'sineInOut');
        }
    }
    eyeOpenTransition(callback, duration) {
        log.info('eyeOpenTransition() duration: ' + duration);
        const eye = Runtime_1.default.instance.face.eye;
        this._stage.addChild(eye);
        eye.active = false;
        eye.visible = true;
        super.transitionFadeInFrom(callback, 1.1, .8, .6, duration);
    }
}
MenuView.LISTPROGRESS_LEFT_MARGIN = 45;
MenuView.LISTPROGRESS_BOTTOM_MARGIN = 40;
MenuView.TITLE_MARGIN = 80;
MenuView.TITLE_BUFFER = 100;
MenuView.TITLE_HEIGHT = 160;
MenuView.LABEL_HEIGHT = 120;
MenuView.MENU_LABEL_BUFFER = 60;
function isMenuView(view) {
    return view instanceof MenuView;
}
exports.isMenuView = isMenuView;
exports.default = MenuView;

},{"../../../Runtime":1,"../../FaceRenderer":99,"../ViewManager":127,"../components/Label":138,"../components/List":139,"../components/ListProgress":140,"../components/MenuButton":141,"./EyeView":151,"./View":156,"./log":158}],154:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const TweenManager_1 = require("../../tween/TweenManager");
const FaceRenderer_1 = require("../../FaceRenderer");
const ViewManager_1 = require("../ViewManager");
class PauseOverlay {
    constructor(options) {
        this.alpha = .7;
        this.duration = ViewManager_1.default.TRANS_TIME;
        this.type = 'sineOut';
        this._isOpen = false;
        if (options) {
            this.applyOptions(options);
        }
        else {
            this.applyDefaults();
        }
    }
    applyOptions(options) {
        if (options.hasOwnProperty('alpha')) {
            this.alpha = options.alpha;
        }
        if (options.hasOwnProperty('duration')) {
            this.duration = options.duration;
        }
        if (options.hasOwnProperty('type')) {
            this.type = options.type;
        }
    }
    applyDefaults() {
        this.alpha = .7;
        this.duration = ViewManager_1.default.TRANS_TIME;
        this.type = 'sineOut';
    }
    open(container) {
        if (!this._isOpen) {
            this._isOpen = true;
            if (!this._overlay) {
                this._overlay = new PIXI.Graphics();
                this._overlay.beginFill(0x000000);
                this._overlay.drawRect(0, 0, FaceRenderer_1.default.WIDTH, FaceRenderer_1.default.HEIGHT);
            }
            container.addChild(this._overlay);
            TweenManager_1.default.stop(this._overlay);
            if (this.duration > 0 && this.alpha > 0) {
                this._overlay.alpha = 0;
                TweenManager_1.default.play(this._overlay, {
                    to: { alpha: this.alpha },
                    duration: this.duration,
                    ease: this.type
                });
            }
            else {
                this._overlay.alpha = this.alpha;
            }
        }
    }
    close() {
        if (this._isOpen) {
            this._isOpen = false;
            if (this._overlay) {
                TweenManager_1.default.stop(this._overlay);
                if (this.duration > 0 && this._overlay.alpha > 0) {
                    TweenManager_1.default.play(this._overlay, {
                        to: { alpha: 0 },
                        duration: this.duration,
                        ease: this.type
                    }, () => {
                        this._overlay.parent.removeChild(this._overlay);
                    });
                }
                else {
                    this._overlay.parent.removeChild(this._overlay);
                }
            }
        }
    }
    destroy() {
        if (this._overlay) {
            TweenManager_1.default.stop(this._overlay);
            if (this._overlay.parent) {
                this._overlay.parent.removeChild(this._overlay);
            }
            this._overlay = null;
        }
    }
}
exports.default = PauseOverlay;

},{"../../FaceRenderer":99,"../../tween/TweenManager":174,"../ViewManager":127}],155:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const View_1 = require("./View");
const Label_1 = require("../components/Label");
const FaceRenderer_1 = require("../../FaceRenderer");
class TextView extends View_1.default {
    constructor() {
        super();
        this.style = null;
        this.margins = null;
        this._type = TextView.DEFAULT_TYPE;
        this._text = null;
        this._label = null;
    }
    static get DEFAULT_TYPE() { return 'TextView'; }
    get text() {
        return this._text;
    }
    set text(message) {
        this._text = message;
        if (this._label) {
            this._label.text = message;
        }
    }
    get label() {
        return this._label;
    }
    assignConfig(viewConfig) {
        if (viewConfig) {
            super.assignConfig(viewConfig);
            if (viewConfig['text']) {
                this._text = viewConfig['text'];
            }
            if (viewConfig.hasOwnProperty('style')) {
                this.style = new PIXI.TextStyle(viewConfig.style);
                if (this.style.fontSize) {
                    this.style.fontSize = Number(this.style.fontSize) || this.style.fontSize;
                }
            }
            if (viewConfig.hasOwnProperty('margins')) {
                this.margins = { width: Number(viewConfig.margins.width), height: Number(viewConfig.margins.height) };
            }
        }
    }
    applyData() {
        this._label = new Label_1.default();
        this._label.id = 'text';
        let style = this.style || TextView.DEFAULT_STYLE.clone();
        this.margins = this.margins || { width: TextView.TEXT_MARGIN_X, height: TextView.TEXT_MARGIN_Y };
        this._label.bounds = { width: FaceRenderer_1.default.WIDTH - (this.margins.width * 2), height: FaceRenderer_1.default.HEIGHT - (this.margins.height * 2) };
        style.wordWrapWidth = this._label.bounds.width;
        this._label.style = style;
        this._label.text = this._text;
        this._label.setTargetPosition(FaceRenderer_1.default.WIDTH / 2, FaceRenderer_1.default.HEIGHT / 2);
        this._label.setTargetAnchor(.5, .5);
        this.addComponent(this._label);
    }
    destroy() {
        this._text = null;
        this._label = null;
        super.destroy();
    }
}
TextView.DEFAULT_STYLE = new PIXI.TextStyle({
    fontSize: 100,
    fontFamily: "Proxima Nova Soft",
    fill: "#FFFFFF",
    fontStyle: 'normal',
    wordWrap: true,
    align: 'center'
});
TextView.TEXT_MARGIN_X = 80;
TextView.TEXT_MARGIN_Y = 80;
function isTextView(view) {
    return view instanceof TextView;
}
exports.isTextView = isTextView;
exports.default = TextView;

},{"../../FaceRenderer":99,"../components/Label":138,"./View":156}],156:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../../../Runtime");
const ViewState_1 = require("../ViewState");
const ComponentGroup_1 = require("../ComponentGroup");
const ViewManager_1 = require("../ViewManager");
const TouchManager_1 = require("../TouchManager");
const ActionData_1 = require("../actions/ActionData");
const FaceRenderer_1 = require("../../FaceRenderer");
const TweenManager_1 = require("../../tween/TweenManager");
const PauseOverlay_1 = require("./PauseOverlay");
const ViewGlobalEvents_1 = require("../ViewGlobalEvents");
const log_1 = require("./log");
const log = log_1.default.createChild('View');
var STATE;
(function (STATE) {
    STATE["INITIALIZED"] = "initialized";
    STATE["DATA_LOADED"] = "data_loaded";
    STATE["ASSETS_LOADED"] = "assets_loaded";
    STATE["LOADED"] = "loaded";
    STATE["OPENED"] = "opened";
    STATE["CLOSED"] = "closed";
    STATE["DESTROYED"] = "destroyed";
    STATE["LOAD_ERROR"] = "load_error";
})(STATE = exports.STATE || (exports.STATE = {}));
var CATEGORY;
(function (CATEGORY) {
    CATEGORY["GUI"] = "gui";
    CATEGORY["DISPLAY"] = "display";
    CATEGORY["EYE"] = "eye";
})(CATEGORY = exports.CATEGORY || (exports.CATEGORY = {}));
class View extends ComponentGroup_1.default {
    constructor() {
        super();
        this.assetManifest = null;
        this.pausedParent = null;
        this.pauseOverlay = null;
        this.closeOnSwipeDown = true;
        this.willPauseParent = false;
        this.pauseOptions = null;
        this.soundSet = 'skill';
        this.transitionStageOnly = false;
        this.borderNeeded = true;
        this.transitionHandler = null;
        this.viewStateStacked = false;
        this._type = View.DEFAULT_TYPE;
        this._category = CATEGORY.GUI;
        this._stage = null;
        this._viewManager = null;
        this._configPath = '';
        this._viewConfig = null;
        this._status = '';
        this._viewState = null;
        this._assetLoad = null;
        this._loadedAssets = [];
        this._assetLoadQueue = null;
        this._assetLoadRequests = null;
        this._transitionsMap = null;
        this._assets = {};
    }
    static get DEFAULT_TYPE() {
        return 'View';
    }
    static get BACK() {
        return 'back';
    }
    static get EMPTY() {
        return 'empty';
    }
    static get PAUSED() {
        return 'paused';
    }
    get stage() {
        return this._stage;
    }
    get viewManager() {
        return this._viewManager;
    }
    get assets() {
        return this._assets;
    }
    get type() {
        return this._type;
    }
    get state() {
        return this._status;
    }
    get category() {
        return this._category;
    }
    init(viewManager, loadAssetsOnComplete = true) {
        this._viewManager = viewManager;
        this._stage = new PIXI.Container();
        this.status = STATE.INITIALIZED;
        this.loadData(loadAssetsOnComplete);
    }
    loadData(loadAssetsOnComplete = true) {
        const proceed = () => {
            this.applyData();
            this.assetManifest = this.resolveAssetDescriptors(this.assetDescriptors);
            this.status = STATE.DATA_LOADED;
            if (loadAssetsOnComplete) {
                this.loadAssets();
            }
        };
        this.loadConfig()
            .then(() => {
            proceed();
        })
            .catch((err) => {
            log.error('loadData() failure loading data', err);
            this.emit(STATE.LOAD_ERROR);
        });
    }
    loadConfig() {
        return new Promise((resolve, reject) => {
            if (!this._viewConfig && this._configPath) {
                this._assetLoad = Runtime_1.default.instance.loader.load({
                    src: this._configPath
                }, (err, configResult) => {
                    this._assetLoad = null;
                    if (err) {
                        reject(new Error('Error loading config path:' + err.message));
                    }
                    else if (configResult) {
                        if (configResult.hasOwnProperty('viewConfig')) {
                            this._viewConfig = Object.assign(configResult.viewConfig, this._viewConfig);
                            this.assignConfig(this._viewConfig);
                        }
                        if (configResult.hasOwnProperty('componentConfigs')) {
                            this.componentConfigs = configResult.componentConfigs;
                        }
                        resolve(this);
                    }
                });
            }
            else {
                resolve(this);
            }
        });
    }
    applyData() {
        super.createComponentsFromConfigs(this.componentConfigs);
    }
    loadAssets(loadedOnComplete = true) {
        if (this.assetManifest && this.assetManifest.length > 0) {
            this._assetLoad = Runtime_1.default.instance.loader.load(this.assetManifest, {
                complete: (err, results) => {
                    this._assetLoad = null;
                    if (err) {
                        log.error('loadAssets() failure loading assets', err);
                        this.emit(STATE.LOAD_ERROR);
                    }
                    Object.assign(this._assets, results);
                    this.status = STATE.ASSETS_LOADED;
                    if (loadedOnComplete) {
                        this.loaded();
                    }
                },
                maxLoads: 1,
                autoStart: false
            });
            this._assetLoad.start();
            this._loadedAssets.push(...this._assetLoad.tokens);
        }
        else {
            this.status = STATE.ASSETS_LOADED;
            if (loadedOnComplete) {
                this.loaded();
            }
        }
    }
    loaded() {
        this.createDisplay(this._stage, this._assets);
        Runtime_1.default.instance.face.plugins.prepare.upload(this.ready.bind(this));
    }
    ready() {
        if (this.closeOnSwipeDown) {
            this.setupSwipeDownToClose();
        }
        super.ready();
        TouchManager_1.default.instance.createRequiredGestures(this);
        this.status = STATE.LOADED;
    }
    set status(status) {
        if (status !== this._status) {
            this._status = status;
            if (this.viewManager) {
                this.viewManager.events.view.emit(new ViewGlobalEvents_1.ViewResult(this, status));
            }
            this.emit(this._status, this);
        }
    }
    pause(flag = true, pauseOptions) {
        if (!flag) {
            TouchManager_1.default.instance.createRequiredGestures(this);
        }
        super.lockInput(flag);
        if (flag) {
            if (!this.pauseOverlay) {
                this.pauseOverlay = new PauseOverlay_1.default(pauseOptions);
            }
            else {
                this.pauseOverlay.applyDefaults();
                if (pauseOptions) {
                    this.pauseOverlay.applyOptions(pauseOptions);
                }
            }
            this.pauseOverlay.open(this.stage);
        }
        else {
            if (this.pauseOverlay) {
                this.pauseOverlay.close();
            }
        }
    }
    destroy() {
        if (this.state === STATE.DESTROYED) {
            log.warn('destroy() : view already destroyed: ' + this.id);
            return;
        }
        else {
            this.status = STATE.DESTROYED;
        }
        super.destroy();
        if (this.pauseOverlay) {
            this.pauseOverlay.destroy();
        }
        if (this._stage) {
            const eye = Runtime_1.default.instance.face.eye;
            if (eye) {
                if (eye.parent && eye.parent === this._stage) {
                    this._stage.removeChild(eye);
                    eye.active = false;
                }
            }
            else {
                log.warn('destroy() Runtime.instance.face.eye was null, should not be possible');
            }
            TweenManager_1.default.stop(this._stage);
            if (this._stage.parent) {
                this._stage.parent.removeChild(this._stage);
            }
            this._stage.destroy({ children: true });
        }
        this._stage = null;
        this._configPath = null;
        this._viewState = null;
        this._viewConfig = null;
        this.pausedParent = null;
        this._viewManager = null;
        this._assetLoadRequests = null;
        if (this._assetLoad) {
            this._assetLoad.cancel();
            this._assetLoad = null;
        }
        Runtime_1.default.instance.loader.unload(this._loadedAssets);
        this._loadedAssets = null;
        this.assetManifest = null;
        Runtime_1.default.instance.face.plugins.prepare.completes.length = 0;
        Runtime_1.default.instance.face.plugins.prepare.queue.length = 0;
        TouchManager_1.default.instance.removeAllGestures();
    }
    destroyAll() {
        if (this.pausedParent) {
            this.pausedParent.destroyAll();
        }
        this.destroy();
    }
    addAssets(assets, callback) {
        let isLoaded = true;
        if (!this._assetLoadQueue) {
            this._assetLoadQueue = [];
            this._assetLoadRequests = [];
        }
        if (assets.hasOwnProperty('src') && assets.hasOwnProperty('id')) {
            if (this.addAssetToQueue(assets)) {
                isLoaded = false;
            }
        }
        else if (Array.isArray(assets)) {
            for (let i = 0; i < assets.length; i++) {
                if (this.addAssetToQueue(assets[i])) {
                    isLoaded = false;
                }
            }
        }
        else if (assets) {
            for (let key in assets) {
                if (assets.hasOwnProperty(key)) {
                    if (this.addAssetToQueue(assets[key])) {
                        isLoaded = false;
                    }
                }
            }
        }
        if (isLoaded) {
            if (callback) {
                callback();
            }
        }
        else {
            this._assetLoadRequests.push({ assets: assets, callback: callback });
            if (!this._assetLoad && this._assetLoadQueue.length > 0) {
                this._assetLoad = Runtime_1.default.instance.loader.load(this._assetLoadQueue, {
                    taskDone: (result, original, load) => {
                        if (this._assetLoadQueue.length > 0) {
                            const tokens = load.addAssets(this._assetLoadQueue);
                            if (tokens.length) {
                                this._loadedAssets.push(...tokens);
                            }
                            this._assetLoadQueue.length = 0;
                        }
                    },
                    complete: (err, results) => {
                        this._assetLoad.removeAllListeners();
                        this._assetLoad = null;
                        if (this._status !== STATE.DESTROYED) {
                            let assetRequest;
                            let i = this._assetLoadRequests.length - 1;
                            if (err) {
                                log.warn('addAssets() error while loading asset(s) ', err);
                                this.emit(STATE.LOAD_ERROR);
                                for (i; i >= 0; i--) {
                                    assetRequest = this._assetLoadRequests[i];
                                    this._assetLoadRequests.splice(i, 1);
                                    if (assetRequest.callback) {
                                        if (this.checkForAssets(assetRequest.assets)) {
                                            assetRequest.callback();
                                        }
                                        else {
                                            this.removeMissingAssets(assetRequest.assets);
                                            assetRequest.callback(err);
                                        }
                                    }
                                }
                            }
                            else {
                                Object.assign(this._assets, results);
                                for (i; i >= 0; i--) {
                                    assetRequest = this._assetLoadRequests[i];
                                    if (this.checkForAssets(assetRequest.assets)) {
                                        this._assetLoadRequests.splice(i, 1);
                                        if (assetRequest.callback) {
                                            assetRequest.callback();
                                        }
                                    }
                                }
                            }
                        }
                    },
                    maxLoads: 0,
                    autoStart: false
                });
                this._assetLoadQueue.length = 0;
                this._assetLoad.start();
                this._loadedAssets.push(...this._assetLoad.tokens);
            }
        }
    }
    removeAssets(assets) {
        if (assets.hasOwnProperty('src') && assets.hasOwnProperty('id')) {
            this.removeAsset(assets);
        }
        else if (Array.isArray(assets)) {
            for (let i = 0; i < assets.length; i++) {
                this.removeAsset(assets[i]);
            }
        }
        else if (assets) {
            for (let key in assets) {
                if (assets.hasOwnProperty(key)) {
                    this.removeAsset(assets[key]);
                }
            }
        }
    }
    resolveAssetDescriptors(assetQueue) {
        let idCheck = {};
        let assetDscrpt;
        let i = assetQueue.length - 1;
        for (i; i >= 0; i--) {
            assetDscrpt = assetQueue[i];
            this.setAssetDescriptorDefaults(assetDscrpt);
            if (assetDscrpt.hasOwnProperty('id')) {
                if (idCheck.hasOwnProperty(assetDscrpt.id)) {
                    assetQueue.splice(i, 1);
                    continue;
                }
                idCheck[assetDscrpt.id] = assetDscrpt;
            }
            else if (assetDscrpt.hasOwnProperty('src')) {
                if (idCheck.hasOwnProperty(assetDscrpt.src)) {
                    assetQueue.splice(i, 1);
                    continue;
                }
                idCheck[assetDscrpt.src] = assetDscrpt;
            }
        }
        idCheck = null;
        return assetQueue;
    }
    addTransition(viewType, openFrom, myTransition, theirTransition, stackDirection) {
        if (!this._transitionsMap) {
            this._transitionsMap = {};
        }
        if (myTransition || theirTransition) {
            let transByView = this._transitionsMap[viewType];
            if (!transByView) {
                transByView = {};
                this._transitionsMap[viewType] = transByView;
            }
            let transByViewStyle;
            if (openFrom) {
                transByViewStyle = transByView[0];
                if (!transByViewStyle) {
                    transByViewStyle = {};
                    transByView[0] = transByViewStyle;
                }
            }
            else {
                transByViewStyle = transByView[1];
                if (!transByViewStyle) {
                    transByViewStyle = {};
                    transByView[1] = transByViewStyle;
                }
            }
            if (!stackDirection) {
                if (myTransition) {
                    transByViewStyle[0] = myTransition;
                }
                if (theirTransition) {
                    transByViewStyle[1] = theirTransition;
                }
            }
            else {
                let transByViewDirection = transByViewStyle[2];
                if (!transByViewDirection) {
                    transByViewStyle[2] = transByViewDirection = {};
                }
                let transByViewDirectionsStyle = transByViewDirection[stackDirection];
                if (!transByViewDirectionsStyle) {
                    transByViewDirection[stackDirection] = transByViewDirectionsStyle = {};
                }
                if (myTransition) {
                    transByViewDirectionsStyle[0] = myTransition;
                }
                if (theirTransition) {
                    transByViewDirectionsStyle[1] = theirTransition;
                }
            }
        }
    }
    applyTransitions(view, openFrom = true, stackDirection) {
        if (this._transitionsMap) {
            let type;
            let isView = true;
            if (typeof view === 'string') {
                type = view;
                isView = false;
            }
            else {
                type = view.type;
            }
            let transByView = this._transitionsMap[type];
            if (transByView) {
                let transByViewStyle;
                if (openFrom) {
                    transByViewStyle = transByView[0];
                }
                else {
                    transByViewStyle = transByView[1];
                }
                if (transByViewStyle) {
                    let myTransition;
                    let theirTransition;
                    if (stackDirection) {
                        const transByViewDirection = transByViewStyle[2];
                        if (transByViewDirection) {
                            const transByViewDirectionStyle = transByViewDirection[stackDirection];
                            if (transByViewDirectionStyle) {
                                myTransition = transByViewDirectionStyle[0];
                                theirTransition = transByViewDirectionStyle[1];
                            }
                        }
                    }
                    if (!myTransition) {
                        myTransition = transByViewStyle[0];
                    }
                    if (!theirTransition) {
                        theirTransition = transByViewStyle[1];
                    }
                    if (myTransition) {
                        this.transitionHandler = myTransition;
                    }
                    if (isView && theirTransition) {
                        view.transitionHandler = theirTransition;
                    }
                }
            }
        }
    }
    open(callback, transitionType) {
        this._viewManager.borderVisible = this.borderNeeded;
        const onOpened = () => {
            this.status = STATE.OPENED;
            if (callback) {
                callback();
            }
        };
        if (this.transitionHandler) {
            if (typeof this.transitionHandler === 'string') {
                transitionType = this.transitionHandler;
                this.transitionHandler = null;
            }
            else {
                this.transitionHandler(onOpened, this);
                this.transitionHandler = null;
                return;
            }
        }
        switch (transitionType) {
            case ViewManager_1.TRANSITION.UP:
                if (this.transitionStageOnly) {
                    this.transitionVerticalIn(true, onOpened);
                    break;
                }
            case ViewManager_1.TRANSITION.DOWN:
                if (this.transitionStageOnly) {
                    this.transitionVerticalIn(false, onOpened);
                    break;
                }
                super.openChildren(onOpened, transitionType);
                break;
            case ViewManager_1.TRANSITION.RIGHT:
                this.transitionHorizontalIn(true, onOpened);
                break;
            case ViewManager_1.TRANSITION.LEFT:
                this.transitionHorizontalIn(false, onOpened);
                break;
            case ViewManager_1.TRANSITION.IN:
                this.transitionFadeIn(onOpened);
                break;
            case ViewManager_1.TRANSITION.OUT:
                this.transitionFadeOut(onOpened);
                break;
            default:
                onOpened();
                break;
        }
    }
    close(callback, transitionType) {
        const onClosed = () => {
            this.status = STATE.CLOSED;
            if (callback) {
                callback();
            }
        };
        if (this.transitionHandler) {
            if (typeof this.transitionHandler === 'string') {
                transitionType = this.transitionHandler;
                this.transitionHandler = null;
            }
            else {
                this.transitionHandler(onClosed, this);
                this.transitionHandler = null;
                return;
            }
        }
        switch (transitionType) {
            case ViewManager_1.TRANSITION.UP:
                if (this.transitionStageOnly) {
                    this.transitionVerticalOut(true, onClosed);
                    break;
                }
            case ViewManager_1.TRANSITION.DOWN:
                if (this.transitionStageOnly) {
                    this.transitionVerticalOut(false, onClosed);
                    break;
                }
                super.closeChildren(onClosed, transitionType);
                break;
            case ViewManager_1.TRANSITION.RIGHT:
                this.transitionHorizontalOut(true, onClosed);
                break;
            case ViewManager_1.TRANSITION.LEFT:
                this.transitionHorizontalOut(false, onClosed);
                break;
            case ViewManager_1.TRANSITION.IN:
                this.transitionFadeIn(onClosed);
                break;
            case ViewManager_1.TRANSITION.OUT:
                this.transitionFadeOut(onClosed);
                break;
            default:
                onClosed();
                break;
        }
    }
    transitionVerticalIn(up, callback, moveEase = 'backOut', tweenTime = ViewManager_1.default.TRANS_TIME) {
        const targetY = this._stage.y;
        let originY = (up) ? +FaceRenderer_1.default.HEIGHT + +this._stage.y : this._stage.y - FaceRenderer_1.default.HEIGHT;
        TweenManager_1.default.play(this._stage, {
            to: { y: targetY },
            from: { y: originY },
            duration: tweenTime,
            ease: moveEase
        }, callback);
    }
    transitionVerticalOut(up, callback, moveEase = 'backIn', tweenTime = ViewManager_1.default.TRANS_TIME) {
        let targetY = (up) ? this._stage.y - FaceRenderer_1.default.HEIGHT : +this._stage.y + +FaceRenderer_1.default.HEIGHT;
        TweenManager_1.default.play(this._stage, {
            to: { y: targetY },
            duration: tweenTime,
            ease: moveEase
        }, callback);
    }
    transitionHorizontalIn(forward, callback, moveEase = 'backOut', tweenTime = ViewManager_1.default.TRANS_TIME) {
        const targetX = this._stage.x;
        let originX = (forward) ? this._stage.x - FaceRenderer_1.default.WIDTH : +this._stage.x + +FaceRenderer_1.default.WIDTH;
        TweenManager_1.default.play(this._stage, {
            to: { x: targetX },
            from: { x: originX },
            duration: tweenTime,
            ease: moveEase
        }, callback);
    }
    transitionHorizontalOut(forward, callback, moveEase = 'backIn', tweenTime = ViewManager_1.default.TRANS_TIME) {
        let targetX = (forward) ? +this._stage.x + +FaceRenderer_1.default.WIDTH : this._stage.x - FaceRenderer_1.default.WIDTH;
        TweenManager_1.default.play(this._stage, {
            to: { x: targetX },
            duration: tweenTime,
            ease: moveEase
        }, callback);
    }
    transitionFadeIn(callback, scaleEase = 'backOut', fadeEase = 'sineOut', tweenTime = ViewManager_1.default.TRANS_TIME) {
        this._stage.pivot.x = this._stage.x = FaceRenderer_1.default.WIDTH / 2;
        this._stage.pivot.y = this._stage.y = FaceRenderer_1.default.HEIGHT / 2;
        TweenManager_1.default.play(this._stage, {
            to: {
                'scale.x': 1,
                'scale.y': 1
            },
            from: {
                'scale.x': 0,
                'scale.y': 0
            },
            duration: tweenTime,
            ease: scaleEase
        }, () => {
            TweenManager_1.default.stop(this._stage);
            this._stage.alpha = 1;
            this._stage.pivot.x = 0;
            this._stage.pivot.y = 0;
            this._stage.x = 0;
            this._stage.y = 0;
            callback();
        });
        TweenManager_1.default.play(this._stage, {
            to: { alpha: 1 },
            from: { alpha: 0 },
            duration: tweenTime,
            ease: fadeEase
        });
    }
    transitionFadeOut(callback, scaleEase = 'backIn', fadeEase = 'sineIn', tweenTime = ViewManager_1.default.TRANS_TIME) {
        this._stage.pivot.x = this._stage.x = FaceRenderer_1.default.WIDTH / 2;
        this._stage.pivot.y = this._stage.y = FaceRenderer_1.default.HEIGHT / 2;
        TweenManager_1.default.play(this._stage, {
            to: {
                'scale.x': 0,
                'scale.y': 0
            },
            duration: tweenTime,
            ease: scaleEase
        }, () => {
            TweenManager_1.default.stop(this._stage);
            this._stage.alpha = 0;
            this._stage.pivot.x = 0;
            this._stage.pivot.y = 0;
            this._stage.x = 0;
            this._stage.y = 0;
            callback();
        });
        TweenManager_1.default.play(this._stage, {
            to: { alpha: 0 },
            duration: tweenTime,
            ease: fadeEase
        });
    }
    transitionFadeOutTo(callback, maxScale = 1.1, targetScale = .8, targetAlpha = .6, tweenTime = ViewManager_1.default.TRANS_TIME / 2) {
        this._stage.pivot.x = this._stage.x = FaceRenderer_1.default.WIDTH / 2;
        this._stage.pivot.y = this._stage.y = FaceRenderer_1.default.HEIGHT / 2;
        TweenManager_1.default.play(this._stage, {
            to: {
                'scale.x': maxScale,
                'scale.y': maxScale,
            },
            duration: tweenTime * .7,
            ease: 'cubicInOut'
        }, () => {
            TweenManager_1.default.play(this._stage, {
                to: {
                    'scale.x': targetScale,
                    'scale.y': targetScale,
                    alpha: targetAlpha
                },
                duration: tweenTime * .3,
                ease: 'cubicIn'
            }, () => {
                this._stage.scale.x = 1;
                this._stage.scale.y = 1;
                this._stage.alpha = 1;
                callback();
            });
        });
    }
    transitionFadeInFrom(callback, maxScale = 1.1, initialScale = .8, initialAlpha = .6, tweenTime = ViewManager_1.default.TRANS_TIME / 2) {
        this._stage.pivot.x = this._stage.x = FaceRenderer_1.default.WIDTH / 2;
        this._stage.pivot.y = this._stage.y = FaceRenderer_1.default.HEIGHT / 2;
        TweenManager_1.default.play(this._stage, {
            to: {
                'scale.x': maxScale,
                'scale.y': maxScale,
                alpha: 1
            },
            from: {
                'scale.x': initialScale,
                'scale.y': initialScale,
                alpha: initialAlpha
            },
            duration: tweenTime * .2,
            ease: 'cubicOut'
        }, () => {
            TweenManager_1.default.play(this._stage, {
                to: {
                    'scale.x': 1,
                    'scale.y': 1
                },
                duration: tweenTime * .8,
                ease: 'cubicInOut'
            }, () => {
                callback();
            });
        });
    }
    actionHandler(action, fromComponent) {
        if (!this.inputLocked) {
            if (action.type === ActionData_1.default.EVENT) {
                if (action.data) {
                    if (action.data.hasOwnProperty('event')) {
                        this.emit(action.data.event, action.data);
                        this.viewManager.events.view.emit(new ViewGlobalEvents_1.ViewResult(this, action.data.event, action.data));
                    }
                    else {
                        log.info('actionHandler() action of type: ' + ActionData_1.default.EVENT + ' must specify an event to fire within data');
                    }
                }
                return;
            }
            else if (action.type === ActionData_1.default.CALLBACK) {
                if (action.data) {
                    if (action.data.hasOwnProperty('callback')) {
                        action.data['callback']();
                    }
                    else {
                        log.info('actionHandler() action of type: ' + ActionData_1.default.CALLBACK + ' must specify a callback within data');
                    }
                }
                return;
            }
            else if (action.type === ActionData_1.default.SOUND) {
                if (action.data) {
                    let soundId = action.data.id;
                    const soundSrc = action.data.src;
                    if (!soundId) {
                        if (soundSrc) {
                            soundId = soundSrc;
                        }
                        else {
                            log.info('actionHandler() action of type: ' + ActionData_1.default.SOUND + ' had neither id nor src were provided for the sound.');
                            return;
                        }
                    }
                    if (Runtime_1.default.instance.sound.exists(this.soundSet + '_' + soundId)) {
                        Runtime_1.default.instance.sound.play(this.soundSet + '_' + soundId);
                    }
                    else if (Runtime_1.default.instance.sound.exists(soundId)) {
                        Runtime_1.default.instance.sound.play(soundId);
                    }
                    else if (soundSrc) {
                        this.addAssets({
                            id: soundId,
                            src: soundSrc,
                            type: 'sound'
                        }, (err) => {
                            if (!err) {
                                Runtime_1.default.instance.sound.play(soundId);
                            }
                        });
                    }
                    else {
                        log.info('actionHandler() action of type: ' + ActionData_1.default.SOUND + ' was not pre-loaded and no src was provided.');
                    }
                }
                return;
            }
            else {
                this._viewManager.actionHandler(action, fromComponent);
            }
        }
    }
    actionEnactor(action) {
        if (this._inputLocked) {
            return false;
        }
        if (action.type === ActionData_1.default.VERBAL_COMMAND) {
            switch (action.data.intent) {
                case 'close':
                    if (this.closeOnSwipeDown && this.hasActions(TouchManager_1.GESTURE.SWIPE_DOWN)) {
                        this.triggerActions(TouchManager_1.GESTURE.SWIPE_DOWN);
                        return true;
                    }
                    break;
            }
        }
        return super.actionEnactor(action);
    }
    setupSwipeDownToClose() {
        if (!super.getActions(TouchManager_1.GESTURE.SWIPE_DOWN)) {
            super.addAction(ActionData_1.default.EVENT, { event: View.BACK }, false, false, TouchManager_1.GESTURE.SWIPE_DOWN);
            super.addAction(ActionData_1.default.CLOSE_VIEW, null, false, false, TouchManager_1.GESTURE.SWIPE_DOWN);
        }
    }
    assignConfig(viewConfig) {
        if (viewConfig) {
            super.assignConfig(viewConfig);
            if (viewConfig.hasOwnProperty('ignoreSwipeDown')) {
                this.closeOnSwipeDown = !viewConfig.ignoreSwipeDown;
            }
            if (viewConfig.hasOwnProperty('soundSet')) {
                this.soundSet = viewConfig.soundSet;
            }
            if (viewConfig.hasOwnProperty('transitionStageOnly')) {
                this.transitionStageOnly = viewConfig.transitionStageOnly;
            }
            if (viewConfig.hasOwnProperty('category')) {
                this._category = viewConfig.category;
            }
            if (viewConfig.hasOwnProperty('pauseParent')) {
                log.warn("Deprecation :: Usage of 'pauseParent' is deprecated, please use 'pause' assigning either a boolean or PauseOptions Object");
                this.willPauseParent = viewConfig.pauseParent;
            }
            if (viewConfig.hasOwnProperty('pauseOptions')) {
                log.warn("Deprecation :: Usage of 'pauseOptions' is deprecated, please use 'pause' assigning either a boolean or PauseOptions Object");
                this.willPauseParent = true;
                this.pauseOptions = (viewConfig.pauseOptions);
            }
            if (viewConfig.hasOwnProperty('pause')) {
                if (typeof viewConfig.pause === 'string') {
                    this.willPauseParent = viewConfig.pause === 'true';
                }
                else if (typeof viewConfig.pause === 'boolean') {
                    this.willPauseParent = !!viewConfig.pause;
                }
                else {
                    this.willPauseParent = true;
                    this.pauseOptions = (viewConfig.pause);
                }
            }
            if (viewConfig.hasOwnProperty('border')) {
                this.borderNeeded = viewConfig.border;
            }
        }
    }
    applyState(viewState) {
        this._viewState = viewState;
        if (viewState.id && !this.id) {
            this.id = viewState.id;
        }
        if (viewState.viewConfig) {
            this._viewConfig = viewState.viewConfig;
            this.assignConfig(this._viewConfig);
        }
        if (viewState.componentConfigs) {
            this.componentConfigs = viewState.componentConfigs;
        }
        if (viewState.configPath) {
            this._configPath = viewState.configPath;
        }
    }
    createState() {
        let viewState = this._viewState || new ViewState_1.default(this.type);
        if (this._configPath) {
            viewState.configPath = this._configPath;
        }
        viewState.id = this.id;
        this._viewConfig = this.updateConfig(this._viewConfig);
        if (this._viewConfig) {
            viewState.viewConfig = this._viewConfig;
            if (this.id) {
                viewState.viewConfig['id'] = this.id;
            }
        }
        viewState.componentConfigs = this.componentConfigs;
        return viewState;
    }
    setAssetDescriptorDefaults(asset) {
        asset.upload = asset.upload !== undefined ? !!asset.upload : true;
        if (typeof asset.cache !== 'string') {
            asset.cache = Runtime_1.default.instance.loader.activeCache;
        }
        return asset;
    }
    addAssetToQueue(asset) {
        if (!this._assets[asset.id]) {
            if (!this.assetManifest.some((element) => {
                return element.id === asset.id;
            })) {
                this.setAssetDescriptorDefaults(asset);
                this._assetLoadQueue.push(asset);
                this.assetManifest.push(asset);
            }
            return true;
        }
        return false;
    }
    removeAsset(asset) {
        this.removeFromManifest(asset);
        if (this._assetLoad && !this._assetLoad.running) {
            this._assetLoad = null;
        }
        if (this._assetLoadRequests) {
            for (let i = this._assetLoadRequests.length - 1; i >= 0; i--) {
                let assetRequest = this._assetLoadRequests[i];
                if (this.checkForAssetRequest(assetRequest, asset)) {
                    this._assetLoadRequests.splice(i, 1);
                    if (assetRequest.callback) {
                        assetRequest.callback(new Error('asset manual removed, asset request will not be completed'));
                    }
                }
            }
        }
    }
    removeFromManifest(asset) {
        let index = this.assetManifest.findIndex((item) => {
            return item.id === asset.id;
        });
        if (index !== -1) {
            this.assetManifest.splice(index, 1);
        }
        index = this._loadedAssets.findIndex((token) => {
            return token.id === asset.id;
        });
        const token = this._loadedAssets[index];
        if (index !== -1) {
            this._loadedAssets.splice(index, 1);
        }
        Runtime_1.default.instance.loader.unload(token);
        delete this._assets[asset.id];
    }
    checkForAssetRequest(assets, asset) {
        if (assets.hasOwnProperty('src') && assets.hasOwnProperty('id')) {
            return assets.id === asset.id;
        }
        else if (Array.isArray(assets)) {
            for (let i = 0; i < assets.length; i++) {
                if (assets[i].id === asset.id) {
                    return true;
                }
            }
        }
        else if (assets) {
            for (let key in assets) {
                if (assets.hasOwnProperty(key)) {
                    if (assets[key].id === asset.id) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
    checkForAssets(assets) {
        if (assets.hasOwnProperty('src') && assets.hasOwnProperty('id')) {
            if (!this._assets[assets.id]) {
                return false;
            }
        }
        else if (Array.isArray(assets)) {
            for (let i = 0; i < assets.length; i++) {
                if (!this._assets[assets[i].id]) {
                    return false;
                }
            }
        }
        else if (assets) {
            for (let key in assets) {
                if (assets.hasOwnProperty(key)) {
                    if (!this._assets[assets[key].id]) {
                        return false;
                    }
                }
            }
        }
        return true;
    }
    removeMissingAssets(assets) {
        let asset;
        if (assets.hasOwnProperty('src') && assets.hasOwnProperty('id')) {
            if (!this._assets[assets.id]) {
                this.removeFromManifest(assets);
            }
        }
        else if (Array.isArray(assets)) {
            for (let i = 0; i < assets.length; i++) {
                asset = assets[i];
                if (!this._assets[asset.id]) {
                    this.removeFromManifest(asset);
                }
            }
        }
        else if (assets) {
            for (let key in assets) {
                if (assets.hasOwnProperty(key)) {
                    asset = assets[key];
                    if (!this._assets[asset.id]) {
                        this.removeFromManifest(asset);
                    }
                }
            }
        }
    }
}
View.STATE = STATE;
View.CATEGORY = CATEGORY;
exports.default = View;

},{"../../../Runtime":1,"../../FaceRenderer":99,"../../tween/TweenManager":174,"../ComponentGroup":123,"../TouchManager":125,"../ViewGlobalEvents":126,"../ViewManager":127,"../ViewState":129,"../actions/ActionData":130,"./PauseOverlay":154,"./log":158}],157:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const View_1 = require("./View");
const MenuView_1 = require("./MenuView");
const EyeView_1 = require("./EyeView");
const ImageView_1 = require("./ImageView");
const ContactsView_1 = require("./ContactsView");
const TextView_1 = require("./TextView");
exports.default = {
    View: View_1.default,
    STATE: View_1.STATE,
    CATEGORY: View_1.CATEGORY,
    MenuView: MenuView_1.default,
    EyeView: EyeView_1.default,
    ImageView: ImageView_1.default,
    ContactsView: ContactsView_1.default,
    TextView: TextView_1.default
};

},{"./ContactsView":150,"./EyeView":151,"./ImageView":152,"./MenuView":153,"./TextView":155,"./View":156}],158:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log_1 = require("../log");
const log = log_1.default.createChild('Views');
exports.default = log;

},{"../log":149}],159:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
require("pixi.js");
require("pixi-animate");
require('pixi-compressed-textures');
PIXI.glCore.VertexArrayObject.FORCE_NATIVE = true;
const FaceRenderer_1 = require("./FaceRenderer");
exports.FaceRenderer = FaceRenderer_1.default;
const tasks_1 = require("./tasks");
exports.tasks = tasks_1.default;
const animation_1 = require("./animation");
exports.animation = animation_1.default;
const tween_1 = require("./tween");
exports.tween = tween_1.default;
const input_1 = require("./input");
exports.input = input_1.default;
const gui_1 = require("./gui");
exports.gui = gui_1.default;
const eye_1 = require("./eye");
exports.eye = eye_1.default;

},{"./FaceRenderer":99,"./animation":106,"./eye":119,"./gui":148,"./input":161,"./tasks":171,"./tween":175,"pixi-animate":undefined,"pixi-compressed-textures":undefined,"pixi.js":undefined}],160:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const electron_1 = require("../../utils/electron");
const log_1 = require("../log");
const FaceRenderer_1 = require("../FaceRenderer");
let HammerJS;
if (electron_1.default) {
    HammerJS = require('hammerjs');
}
class GestureManager {
    constructor(renderer) {
        this._hammerManager = null;
        this._log = null;
        this._hammerManager = new HammerJS.Manager(renderer.view);
        this._log = log_1.default.createChild('GestureManager');
    }
    static init(renderer) {
        return new GestureManager(renderer);
    }
    get hammer() {
        return HammerJS;
    }
    stop() {
        this._hammerManager.stop();
    }
    addStageGesture(hammerType, gestureOptions, gestureCallback) {
        if (!this._hammerManager) {
            throw new Error("The pixi HammerJS Manager is null.  Has init been called?");
        }
        if (!gestureOptions.event) {
            throw new Error("Invalid event string.");
        }
        let hammerResult = this._hammerManager.get(gestureOptions.event);
        if (hammerResult) {
            if (this._hammerManager.handlers[gestureOptions.event].indexOf(gestureCallback) === -1) {
                this._hammerManager.handlers[gestureOptions.event].push(gestureCallback);
            }
        }
        else {
            hammerResult = new hammerType(gestureOptions);
            this._hammerManager.add(hammerResult);
            this._hammerManager.on(gestureOptions.event, gestureCallback);
        }
        return hammerResult;
    }
    removeStageGesture(gestureRecognizer) {
        if (gestureRecognizer.hasOwnProperty('options')) {
            this._hammerManager.off(gestureRecognizer.options.event);
            this._hammerManager.remove(gestureRecognizer);
        }
    }
    spoofGesture(gestureEvent = 'tap', xPos = 0, yPos = 0) {
        this._log.info("spoofing gesture", gestureEvent.toLowerCase(), xPos, yPos);
        this._hammerManager.emit(gestureEvent.toLowerCase(), { pointers: [{ clientX: xPos, clientY: yPos }] });
    }
    spoofGestureWithOptions(gestureEvent = 'tap', options = {}) {
        this._hammerManager.emit(gestureEvent, options);
    }
    spoofFullPanGesture(panLeft = true) {
        const pointers = [FaceRenderer_1.default.WIDTH * 0.75, FaceRenderer_1.default.WIDTH * 0.5, FaceRenderer_1.default.WIDTH * 0.25];
        const movements = [-31, -198, -31].map(move => panLeft ? move : move * -1);
        (panLeft ? pointers : pointers.reverse()).forEach((val, index, array) => {
            this._hammerManager.emit(GestureManager.PAN, { isFinal: false, srcEvent: { movementX: movements[index] }, pointers: [{ x: val, clientY: 310 }] });
            if (index === array.length - 1) {
                this._hammerManager.emit(GestureManager.PAN, { isFinal: true, pointers: [{ x: val, clientY: 310 }] });
            }
        });
    }
}
GestureManager.PAN = 'pan';
GestureManager.PANSTART = 'panstart';
GestureManager.PANMOVE = 'panmove';
GestureManager.PANEND = 'panend';
GestureManager.PANCANCEL = 'pancancel';
GestureManager.PANLEFT = 'panleft';
GestureManager.PANRIGHT = 'panright';
GestureManager.PANUP = 'panup';
GestureManager.PANDOWN = 'pandown';
GestureManager.SWIPE = 'swipe';
GestureManager.SWIPELEFT = 'swipeleft';
GestureManager.SWIPERIGHT = 'swiperight';
GestureManager.SWIPEUP = 'swipeup';
GestureManager.SWIPEDOWN = 'swipedown';
GestureManager.TAP = 'tap';
exports.default = GestureManager;

},{"../../utils/electron":205,"../FaceRenderer":99,"../log":162,"hammerjs":undefined}],161:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const GestureManager_1 = require("./GestureManager");
exports.default = {
    GestureManager: GestureManager_1.default
};

},{"./GestureManager":160}],162:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log_1 = require("../log");
exports.default = log_1.default.createChild('Rendering');

},{"../log":75}],163:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_loader_1 = require("jibo-loader");
class ColorAlphaTask extends jibo_loader_1.Task {
    static test(asset) {
        return !!asset.src && !!asset.alpha && /\.(jpg|png|jpeg|gif)$/i.test(asset.src) && /\.(png|gif)$/i.test(asset.alpha);
    }
    static mergeAlpha(rgbImage, alphaImage, canvas) {
        if (!canvas) {
            canvas = document.createElement("canvas");
        }
        canvas.width = Math.max(alphaImage.width, rgbImage.width);
        canvas.height = Math.max(alphaImage.height, rgbImage.height);
        const ctx = canvas.getContext("2d");
        ctx.save();
        ctx.drawImage(rgbImage, 0, 0);
        ctx.globalCompositeOperation = "destination-in";
        ctx.drawImage(alphaImage, 0, 0);
        ctx.restore();
        return canvas;
    }
    constructor(manager, asset) {
        super(manager, asset, asset.color);
        this.src = this.prepare(asset.src);
        this.alpha = this.prepare(asset.alpha);
    }
    start(callback) {
        this.load({
            _alpha: this.alpha,
            _src: this.src
        }, (err, results) => {
            if (err) {
                return callback(err);
            }
            callback(null, ColorAlphaTask.mergeAlpha(results._src, results._alpha));
            results._src.src = results._alpha.src = '';
        });
    }
}
exports.default = ColorAlphaTask;

},{"jibo-loader":undefined}],164:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_loader_1 = require("jibo-loader");
const Runtime_1 = require("../../Runtime");
const log_1 = require("./log");
const workerPool = [];
class CompressedImageTask extends jibo_loader_1.Task {
    static test(asset) {
        return asset.src && /(\.dds|\.crn)$/.test(asset.src);
    }
    constructor(manager, asset) {
        super(manager, asset, asset.src);
        this.src = this.prepare(asset.src);
    }
    start(callback) {
        if ((/\.crn$/.test(this.src))) {
            this.unCrunch(this.src, callback);
            return;
        }
        const xhr = new XMLHttpRequest();
        xhr.addEventListener('load', (ev) => {
            const output = PIXI.compressedTextures.CompressedImage.loadFromArrayBuffer(xhr.response, this.src);
            callback(null, output);
        }, false);
        xhr.addEventListener('error', function (err) {
            log_1.default.warn('CompressedImageTask.start had an XHR error: ', err);
            callback(err);
        });
        xhr.open('GET', this.src, true);
        xhr.responseType = 'arraybuffer';
        xhr.send();
    }
    unCrunch(data, callback) {
        let loader = workerPool.pop() || new Worker(Runtime_1.default.instance.utils.PathUtils.getAssetUri('jibo://resources/workerJS/webgl-texture-util.js'));
        loader.onmessage = (msg) => {
            loader.onmessage = null;
            workerPool.push(loader);
            if (msg.data.error) {
                callback(msg.data.error);
                return;
            }
            const data = msg.data;
            let output;
            const CompressedImage = PIXI.compressedTextures.CompressedImage;
            if (data.format) {
                output = new CompressedImage(this.src, data.data, 'CRN', data.width, data.height, data.levels, data.format);
            }
            else {
                output = CompressedImage.loadFromArrayBuffer(data.data, this.src);
            }
            output.preserveSource = false;
            callback(null, output);
        };
        loader.postMessage({ src: data });
    }
}
exports.default = CompressedImageTask;

},{"../../Runtime":1,"./log":172,"jibo-loader":undefined}],165:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_loader_1 = require("jibo-loader");
const jibo_plugins_1 = require("jibo-plugins");
const KeysLoader_1 = require("../animation/KeysLoader");
class AnimDataTask extends jibo_loader_1.Task {
    static test(asset) {
        return asset.type === "keys-data" && !!asset.root &&
            (!!asset.src && /\.keys$/i.test(asset.src));
    }
    constructor(manager, asset) {
        super(manager, asset, asset.src);
        this.src = this.prepare(asset.src);
        this.root = asset.root;
    }
    start(callback) {
        let root = jibo_plugins_1.PathUtils.findRoot();
        const loader = new KeysLoader_1.default(this.src, root, this.id);
        loader.load(callback);
    }
}
exports.default = AnimDataTask;

},{"../animation/KeysLoader":102,"jibo-loader":undefined,"jibo-plugins":undefined}],166:[function(require,module,exports){
"use strict";
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_loader_1 = require("jibo-loader");
const jibo_plugins_1 = require("jibo-plugins");
const Sound_1 = require("../../sound/Sound");
const Timeline_1 = require("../animation/Timeline");
const path = require("path");
const KeysData_1 = require("../animation/KeysData");
const KeysLoader_1 = require("../animation/KeysLoader");
const async = require("async");
const jibo_cai_utils_1 = require("jibo-cai-utils");
const fs = require("fs");
const log_1 = require("./log");
const jiboKeyframes = require('jibo-keyframes');
class KeysTask extends jibo_loader_1.Task {
    static test(asset) {
        return asset.type === "keys" && !!asset.root &&
            ((!!asset.src && /\.keys$/i.test(asset.src)) || !!asset.data);
    }
    constructor(manager, asset) {
        super(manager, asset, asset.src);
        this.needsCache = true;
        this.src = this.prepare(asset.src);
        this.options = asset.options;
        this.data = asset.data;
        this.root = asset.root;
        this.upload = asset.upload === undefined ? true : asset.upload;
    }
    start(callback) {
        const keys = new KeysData_1.default(this.id, this.src, this.cache);
        keys.root = this.root;
        this.dataSupplied = !!this.data;
        let assetFileFound = false;
        let label = 'Data load';
        async.waterfall([
            (done) => __awaiter(this, void 0, void 0, function* () {
                let root = jibo_plugins_1.PathUtils.findRoot();
                let projectName = jibo_plugins_1.PathUtils.getProjectName(root);
                const parent = jibo_plugins_1.PathUtils.findRoot(path.resolve(this.src));
                const assetPack = jibo_plugins_1.PathUtils.getProjectName(parent);
                keys.assetPack = assetPack === projectName ? '' : assetPack;
                if (this.data) {
                    done(null, this.data);
                }
                else {
                    let animSrc = yield jibo_cai_utils_1.PromiseUtils.promisify(cb => jiboKeyframes.getAnimFilePath(this.src, cb));
                    let assetSrc = yield jibo_cai_utils_1.PromiseUtils.promisify(cb => jiboKeyframes.getAssetsFilePath(this.src, cb));
                    if (animSrc) {
                        keys.dotAnimSrc = animSrc;
                    }
                    if (animSrc && assetSrc) {
                        label = `Assets file load ${assetSrc}`;
                        console.time(label);
                        assetFileFound = true;
                        const data = fs.readFileSync(assetSrc, 'utf8');
                        let json = JSON.parse(data);
                        done(null, json);
                    }
                    else {
                        label = `Keys file load ${this.src}`;
                        console.time(label);
                        const loader = new KeysLoader_1.default(this.src, root, this.id);
                        loader.load(done);
                    }
                }
            }),
            (data, done) => {
                log_1.default.debug(label);
                console.timeEnd(label);
                console.time('Asset loading');
                this.data = data;
                let assets;
                if (assetFileFound) {
                    assets = this.convertAssetPaths(data, keys);
                }
                else {
                    keys.data = data;
                    assets = this.getAssetsFromKeys(keys);
                }
                if (!assets.length) {
                    return done(null, {});
                }
                this.load(assets, done);
            },
            (results, done) => {
                console.timeEnd('Asset loading');
                for (let id in results) {
                    if (results[id] instanceof Timeline_1.default) {
                        keys.addTimeline(id, results[id]);
                    }
                    else if (results[id] instanceof Sound_1.default) {
                        keys.addSound(id, results[id]);
                    }
                    else if (results[id] instanceof PIXI.Texture) {
                        keys.addTexture(id, results[id]);
                    }
                }
                done();
            }
        ], (err, results) => {
            if (err) {
                keys.destroy();
                callback(err);
                return;
            }
            callback(null, keys);
        });
    }
    getAssetsFromKeys(keys) {
        const assets = [];
        keys.data.layers.forEach((layer) => {
            layer.keyframes.forEach((keyframe) => {
                const AudioEvent = keyframe.value.AudioEvent;
                const Pixi = keyframe.value.Pixi;
                const Texture = keyframe.value.Texture;
                if (AudioEvent) {
                    assets.push({
                        id: AudioEvent.file,
                        type: 'sound',
                        src: jibo_plugins_1.PathUtils.getAudioUri(AudioEvent.file, keys.assetPack, keys.root),
                        cache: this.cache
                    });
                }
                else if (Pixi) {
                    assets.push({
                        id: Pixi,
                        type: 'timeline',
                        upload: this.upload,
                        src: jibo_plugins_1.PathUtils.getTimelineUri(Pixi, keys.assetPack, keys.root),
                        cache: this.cache
                    });
                }
                else if (jibo_plugins_1.PathUtils.isImage(Texture)) {
                    const src = jibo_plugins_1.PathUtils.getAssetUri(Texture, keys.assetPack, keys.root);
                    assets.push({
                        id: src,
                        type: 'texture',
                        src: src,
                        cache: this.cache
                    });
                }
            });
        });
        return assets;
    }
    convertAssetPaths(data, keys) {
        const assets = [];
        data.forEach((assetObj) => {
            switch (assetObj.type) {
                case 'sound':
                    assetObj.src = jibo_plugins_1.PathUtils.getAudioUri(assetObj.src, keys.assetPack, keys.root);
                    break;
                case 'timeline':
                    assetObj.upload = this.upload;
                    assetObj.src = jibo_plugins_1.PathUtils.getTimelineUri(assetObj.src, keys.assetPack, keys.root);
                    break;
                case 'texture':
                    assetObj.src = jibo_plugins_1.PathUtils.getAssetUri(assetObj.src, keys.assetPack, keys.root);
                    assetObj.id = assetObj.src;
                    break;
                case 'metadata':
                    return;
            }
            assetObj.cache = this.cache;
            assets.push(assetObj);
        });
        return assets;
    }
}
exports.default = KeysTask;

},{"../../sound/Sound":192,"../animation/KeysData":101,"../animation/KeysLoader":102,"../animation/Timeline":105,"./log":172,"async":undefined,"fs":undefined,"jibo-cai-utils":undefined,"jibo-keyframes":undefined,"jibo-loader":undefined,"jibo-plugins":undefined,"path":undefined}],167:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_loader_1 = require("jibo-loader");
const Shapes_1 = require("../animation/Shapes");
class ShapesTask extends jibo_loader_1.Task {
    static test(asset) {
        return asset.type === "shapes" && !!asset.src && /\.shapes\.(json|txt)$/i.test(asset.src);
    }
    constructor(manager, asset) {
        super(manager, asset, asset.src);
        this.src = this.prepare(asset.src);
    }
    start(callback) {
        this.simpleLoad(this.src, (err, results) => {
            if (err) {
                return callback(err);
            }
            callback(null, new Shapes_1.default(this.id, results));
        });
    }
}
exports.default = ShapesTask;

},{"../animation/Shapes":103,"jibo-loader":undefined}],168:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_loader_1 = require("jibo-loader");
const Runtime_1 = require("../../Runtime");
const Spritesheet_1 = require("../animation/Spritesheet");
const path = require("path");
class SpritesheetTask extends jibo_loader_1.Task {
    static test(asset) {
        return asset.type === "spritesheet" && !!asset.src && /\.(json)$/i.test(asset.src);
    }
    constructor(manager, asset) {
        super(manager, asset, asset.src);
        this.needsCache = true;
        this.src = this.prepare(asset.src);
        this.upload = !!asset.upload;
    }
    start(callback) {
        this.simpleLoad(this.src, (err, data) => {
            if (err) {
                return callback(err);
            }
            if (typeof data !== "object" || !data.meta || !data.frames) {
                return callback(new Error('Spritesheet is not a valid format'));
            }
            const imgSrc = path.join(path.dirname(this.src), data.meta.image);
            this.load(imgSrc, (err, image) => {
                if (err) {
                    return callback(err);
                }
                const baseTexture = new PIXI.BaseTexture(image);
                baseTexture.imageUrl = imgSrc;
                if (this.upload) {
                    Runtime_1.default.instance.face.textureManager.updateTexture(baseTexture);
                }
                callback(null, new Spritesheet_1.default(baseTexture, data.frames, data.meta.scale || 1));
            });
        });
    }
}
exports.default = SpritesheetTask;

},{"../../Runtime":1,"../animation/Spritesheet":104,"jibo-loader":undefined,"path":undefined}],169:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_loader_1 = require("jibo-loader");
const ColorAlphaTask_1 = require("./ColorAlphaTask");
const Runtime_1 = require("../../Runtime");
class TextureTask extends jibo_loader_1.Task {
    static test(asset) {
        return asset.type === "texture" && !!asset.src;
    }
    constructor(manager, asset) {
        super(manager, asset, asset.src);
        this.needsCache = true;
        this.src = this.prepare(asset.src);
        this.alpha = asset.alpha ? this.prepare(asset.alpha) : null;
        this.upload = !!asset.upload;
        this.format = 'image';
    }
    start(callback) {
        const assets = {};
        assets._color = {
            src: this.src,
            remote: this.remote,
            timeout: this.timeout,
            format: this.format
        };
        if (this.alpha) {
            assets._alpha = {
                src: this.alpha,
                remote: this.remote,
                timeout: this.timeout,
                format: this.format
            };
        }
        this.load(assets, (err, results) => {
            if (err) {
                return callback(err);
            }
            let image;
            if (!results._alpha) {
                image = results._color;
            }
            else {
                image = ColorAlphaTask_1.default.mergeAlpha(results._color, results._alpha);
            }
            const baseTexture = new PIXI.BaseTexture(image);
            baseTexture.imageUrl = this.src;
            const texture = new PIXI.Texture(baseTexture);
            if (this.upload) {
                Runtime_1.default.instance.face.textureManager.updateTexture(texture);
            }
            callback(null, texture);
        });
    }
}
exports.default = TextureTask;

},{"../../Runtime":1,"./ColorAlphaTask":163,"jibo-loader":undefined}],170:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_loader_1 = require("jibo-loader");
const Timeline_1 = require("../animation/Timeline");
const jibo_plugins_1 = require("jibo-plugins");
const path = require("path");
const vm = require("vm");
const Runtime_1 = require("../../Runtime");
class TimelineTask extends jibo_loader_1.Task {
    static test(asset) {
        return asset.type === "timeline" && !!asset.src && /\.js$/i.test(asset.src);
    }
    constructor(manager, asset) {
        super(manager, asset, asset.src);
        this.needsCache = true;
        this.src = this.prepare(asset.src);
        this.upload = !!asset.upload;
        this.instance = asset.instance !== undefined ? !!asset.instance : true;
    }
    start(callback) {
        const timeline = new Timeline_1.default();
        this.load({
            src: this.src,
            format: 'text'
        }, (err, result) => {
            if (this.status !== jibo_loader_1.Task.RUNNING) {
                return;
            }
            if (err) {
                return callback(err);
            }
            let library;
            const oldFromFrame = PIXI.Texture.fromFrame;
            try {
                const context = {
                    module: { exports: {} },
                    PIXI: PIXI
                };
                PIXI.Texture.fromFrame = timeline.getTexture.bind(timeline);
                vm.runInNewContext(result, context);
                library = context.module.exports;
                PIXI.Texture.fromFrame = oldFromFrame;
            }
            catch (e) {
                PIXI.Texture.fromFrame = oldFromFrame;
                return callback(e);
            }
            timeline.library = library;
            const assets = this.getAssets(timeline);
            if (assets.length) {
                this.load(assets, (err, results) => {
                    if (err) {
                        return callback(err);
                    }
                    if (this.upload && Runtime_1.default.instance.face) {
                        timeline.upload(Runtime_1.default.instance.face, () => {
                            callback(null, timeline);
                        });
                    }
                    else {
                        callback(null, timeline);
                    }
                });
            }
            else {
                callback(null, timeline);
            }
        });
    }
    getAssets(timeline) {
        let basePath = this.src;
        if (jibo_plugins_1.PathUtils.getAssetPack(basePath)) {
            basePath = jibo_plugins_1.PathUtils.getAssetUri(basePath);
        }
        basePath = path.dirname(basePath);
        const results = [];
        const assets = timeline.library.stage.assets;
        for (let id in assets) {
            let src = assets[id];
            if (src.search(/\.shapes\.(txt|json)$/i) > -1) {
                results.push({
                    id: id,
                    src: path.join(basePath, src),
                    type: 'shapes',
                    complete: (err, result) => {
                        if (err) {
                            return;
                        }
                        timeline.addShapes(result);
                    }
                });
            }
            else if (src.search(/\.(png|jpg|gif|dds|crn)$/i) > -1) {
                results.push({
                    id: id,
                    src: path.join(basePath, src),
                    type: 'texture',
                    complete: (err, result) => {
                        if (err) {
                            return;
                        }
                        timeline.addTexture(result, id);
                    },
                    cache: this.cache
                });
            }
            else if (src.search(/\.json$/i) > -1) {
                results.push({
                    id: id,
                    src: path.join(basePath, src),
                    type: 'spritesheet',
                    complete: (err, result) => {
                        if (err) {
                            return;
                        }
                        timeline.addSpritesheet(result);
                    },
                    cache: this.cache
                });
            }
        }
        return results;
    }
}
exports.default = TimelineTask;

},{"../../Runtime":1,"../animation/Timeline":105,"jibo-loader":undefined,"jibo-plugins":undefined,"path":undefined,"vm":undefined}],171:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const TextureTask_1 = require("./TextureTask");
const ColorAlphaTask_1 = require("./ColorAlphaTask");
const TimelineTask_1 = require("./TimelineTask");
const ShapesTask_1 = require("./ShapesTask");
const KeysTask_1 = require("./KeysTask");
const KeysDataTask_1 = require("./KeysDataTask");
const SpritesheetTask_1 = require("./SpritesheetTask");
const CompressedImageTask_1 = require("./CompressedImageTask");
exports.default = {
    ColorAlphaTask: ColorAlphaTask_1.default,
    TimelineTask: TimelineTask_1.default,
    ShapesTask: ShapesTask_1.default,
    TextureTask: TextureTask_1.default,
    KeysTask: KeysTask_1.default,
    KeysDataTask: KeysDataTask_1.default,
    SpritesheetTask: SpritesheetTask_1.default,
    CompressedImageTask: CompressedImageTask_1.default
};

},{"./ColorAlphaTask":163,"./CompressedImageTask":164,"./KeysDataTask":165,"./KeysTask":166,"./ShapesTask":167,"./SpritesheetTask":168,"./TextureTask":169,"./TimelineTask":170}],172:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log_1 = require("../log");
exports.default = log_1.default.createChild('Tasks');

},{"../log":162}],173:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
const eases = require("eases");
const log_1 = require("./log");
const log = log_1.default.createChild('Tween');
class Tween extends events_1.EventEmitter {
    constructor() {
        super(...arguments);
        this._complete = null;
        this._inProcess = false;
    }
    init(target, options, complete) {
        options = Object.assign({
            duration: 500,
            ease: 'linear',
            delay: 0,
            to: null,
            from: null
        }, options || {});
        if (!eases[options.ease]) {
            throw new Error(`'${options.ease}' is not a defined ease.`);
        }
        this._target = target;
        this._end = !options.to ? this.endDefaults(options.from) : options.to;
        this._start = !options.from ? this.startDefaults(this._end) : options.from;
        if (!this._end || !this._start || !this.validate(this._end, this._start)) {
            log.error("given start and end values that are incompatible to: %O, from: %O", this._end, this._start);
            throw new Error('Start and end values for tween are incompatible.');
        }
        this._time = 0;
        this._elapsed = 0;
        this._ease = eases[options.ease];
        this._delay = options.delay;
        this._duration = options.duration;
        this._complete = complete;
        this.assign(this._start);
        process.nextTick(() => {
            this.emit('change', this._target);
        });
    }
    reset() {
        this.removeAllListeners();
        this._complete = null;
        this._target = null;
        this._ease = null;
        this._time = 0;
        this._delay = 0;
        this._elapsed = 0;
        this._duration = 0;
        this.paused = false;
        this._inProcess = false;
    }
    get delay() {
        return this._delay;
    }
    set delay(value) {
        this._delay = value;
    }
    get duration() {
        return this._duration;
    }
    get time() {
        return this._time;
    }
    get target() {
        return this._target;
    }
    get inProcess() {
        return this._inProcess;
    }
    completed() {
        this._inProcess = true;
        this.assign(this._end);
        if (this._complete) {
            this._complete();
            this._complete = null;
        }
        this.emit('complete', this._target);
    }
    update(elapsed) {
        if (this.paused) {
            return;
        }
        this._elapsed += elapsed;
        const startTime = this._elapsed - this._delay;
        const localElapsedTime = Math.max(0, Math.min(startTime, this._duration));
        if (localElapsedTime >= 0 && localElapsedTime <= this._duration) {
            this._time = localElapsedTime / this._duration;
        }
        const modified = this._ease(this._time);
        for (let prop in this._start) {
            if (typeof this._start[prop] !== 'number') {
                continue;
            }
            this.assignValue(prop, this.lerp(this._start[prop], this._end[prop], modified));
        }
        this.emit('change', this._target);
    }
    assign(values) {
        for (let prop in values) {
            this.assignValue(prop, values[prop]);
        }
    }
    assignValue(prop, value) {
        if (prop.indexOf('.') < 0) {
            this._target[prop] = value;
        }
        else {
            const parts = prop.split('.');
            let target = this._target;
            while (parts.length > 1) {
                target = target[parts.shift()];
                if (!target) {
                    throw new Error(`Property '${prop}' is invalid on target.`);
                }
            }
            target[parts.shift()] = value;
        }
    }
    lerp(v0, v1, t) {
        return (1.0 - t) * v0 + t * v1;
    }
    startDefaults(to) {
        const start = {};
        for (let prop in to) {
            if (prop.indexOf('.') < 0) {
                start[prop] = this._target[prop];
            }
            else {
                const parts = prop.split('.');
                let target = this._target;
                while (parts.length > 1) {
                    target = target[parts.shift()];
                    if (!target) {
                        throw new Error(`Property '${prop}' is invalid on target.`);
                    }
                }
                start[prop] = target[parts.shift()];
            }
        }
        return start;
    }
    endDefaults(from) {
        const end = {};
        for (let prop in from) {
            if (prop.indexOf('.') < 0) {
                end[prop] = this._target[prop];
            }
            else {
                const parts = prop.split('.');
                let target = this._target;
                while (parts.length > 1) {
                    target = target[parts.shift()];
                    if (!target) {
                        throw new Error(`Property '${prop}' is invalid on target.`);
                    }
                }
                end[prop] = target[parts.shift()];
            }
        }
        return end;
    }
    validate(obj1, obj2) {
        const a1 = Object.keys(obj1);
        const a2 = Object.keys(obj2);
        const result = a1.filter((val) => {
            return a2.indexOf(val) < 0;
        });
        return result.length === 0;
    }
}
exports.default = Tween;

},{"./log":176,"eases":undefined,"events":undefined}],174:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Tween_1 = require("./Tween");
const assert = require("assert");
const async = require("async");
class TweenManager {
    static play(target, options, complete) {
        assert.equal(typeof target, 'object', 'target must be an object');
        const tween = this._create();
        tween.init(target, options, complete);
        this._tweens.push(tween);
        return tween;
    }
    static playSet(targets, options, setOptions) {
        if (typeof setOptions === "function") {
            setOptions = {
                complete: setOptions
            };
        }
        setOptions = Object.assign({
            focus: 0,
            delay: 0,
            focusIsLast: false,
            complete: null,
            completeOnFirst: false
        }, setOptions || {});
        const startDelay = options.delay || 0;
        const tasks = [];
        let focus = setOptions.focus;
        const delay = setOptions.delay;
        const focusIsLast = !!setOptions.focusIsLast;
        const complete = setOptions.complete;
        let completeOnFirst = (complete !== null) && !!setOptions.completeOnFirst;
        const numTargets = targets.length;
        if (focus >= numTargets) {
            focus = numTargets - 1;
        }
        else if (focus < 0) {
            focus = 0;
        }
        const delays = new Array(numTargets);
        delays.fill(0);
        if (delay > 0) {
            delays[focus] = 0;
            let maxDelay = 0;
            let currentDelay = delay;
            for (let i = focus - 1; i >= 0; i--) {
                delays[i] = currentDelay;
                maxDelay = Math.max(currentDelay, maxDelay);
                currentDelay += delay;
            }
            currentDelay = delay;
            for (let i = focus + 1; i < numTargets; i++) {
                delays[i] = currentDelay;
                maxDelay = Math.max(currentDelay, maxDelay);
                currentDelay += delay;
            }
            if (focusIsLast) {
                delays.forEach((d, i) => {
                    delays[i] = maxDelay - d;
                });
            }
        }
        delays.forEach((d, i) => {
            const target = targets[i];
            const localOptions = Object.assign({}, options);
            localOptions.delay = startDelay + d;
            const tween = this.play(target, localOptions);
            tween.paused = true;
            tasks.push((done) => {
                tween.paused = false;
                tween.once('complete', () => {
                    done(null);
                    if (completeOnFirst) {
                        completeOnFirst = false;
                        if (complete) {
                            complete();
                        }
                    }
                });
            });
        });
        if (completeOnFirst) {
            async.parallel(tasks);
        }
        else {
            async.parallel(tasks, () => {
                if (complete) {
                    complete();
                }
            });
        }
    }
    static stop(target) {
        const tweens = this._tweens;
        if (!target) {
            while (tweens.length) {
                this._pool(tweens.pop());
            }
        }
        else {
            for (let i = tweens.length - 1, tween; i >= 0; i--) {
                tween = tweens[i];
                if (tween.target === target) {
                    if (!tween.inProcess) {
                        this._pool(tween);
                    }
                }
            }
        }
    }
    static stopCheck(check, against) {
        const tweens = this._tweens;
        for (let i = tweens.length - 1, tween; i >= 0; i--) {
            tween = tweens[i];
            if (check(tween.target, against)) {
                if (!tween.inProcess) {
                    this._pool(tween);
                }
            }
        }
    }
    static set paused(paused) {
        this._tweens.forEach((tween) => {
            tween.paused = paused;
        });
    }
    static update(elapsed) {
        const tweens = this._tweens;
        for (let i = tweens.length - 1, tween; i >= 0; i--) {
            tween = tweens[i];
            if (tween) {
                if (tween.time >= 0 && tween.time < 1) {
                    tween.update(elapsed);
                }
                if (tween.time >= 1) {
                    tween.completed();
                    this._pool(tween);
                }
            }
        }
    }
    static _pool(tween) {
        const i = this._tweens.indexOf(tween);
        tween.reset();
        if (i > -1) {
            this._tweens.splice(i, 1);
            this._tweensPool.push(tween);
        }
    }
    static _create() {
        if (this._tweensPool.length) {
            return this._tweensPool.pop();
        }
        return new Tween_1.default();
    }
}
TweenManager._tweens = [];
TweenManager._tweensPool = [];
exports.default = TweenManager;

},{"./Tween":173,"assert":undefined,"async":undefined}],175:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const TweenManager_1 = require("./TweenManager");
const Tween_1 = require("./Tween");
exports.default = {
    TweenManager: TweenManager_1.default,
    Tween: Tween_1.default
};

},{"./Tween":173,"./TweenManager":174}],176:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log_1 = require("../../log");
exports.default = log_1.default.createChild('GUI');

},{"../../log":75}],177:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class SessionManager {
    constructor() {
        this.token = "abcdef";
    }
}
exports.default = SessionManager;

},{}],178:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_typed_events_1 = require("jibo-typed-events");
class GlobalEvent extends jibo_typed_events_1.Event {
    constructor(name) {
        super(name);
        this._subscriberOff = [];
        this._subscriberOn = [];
    }
    checkLastListener() {
        if (this.listenerCount() === 0) {
            this.emitNoListeners();
        }
    }
    onNoListeners(handler) {
        this._subscriberOff.push(handler);
        return this;
    }
    emitNoListeners() {
        let copy = this._subscriberOff.slice();
        for (let i = 0; i < copy.length; i++) {
            let handler = copy[i];
            handler();
        }
    }
    onAddedListener(handler) {
        this._subscriberOn.push(handler);
        return this;
    }
    emitAddListener() {
        let copy = this._subscriberOn.slice();
        for (let i = 0; i < copy.length; i++) {
            let handler = copy[i];
            handler();
        }
    }
    on(handler) {
        this.emitAddListener();
        return super.on(handler);
    }
    once(handler) {
        this.emitAddListener();
        return super.once(handler);
    }
    addListener(handler) {
        this.emitAddListener();
        return super.addListener(handler);
    }
    removeListener(handler) {
        const result = super.removeListener(handler);
        this.checkLastListener();
        return result;
    }
    off(handler) {
        const result = super.removeListener(handler);
        this.checkLastListener();
        return result;
    }
    removeAllListeners() {
        this.emitNoListeners();
        return super.removeAllListeners();
    }
    removeFirstListener() {
        const result = super.removeFirstListener();
        this.checkLastListener();
        return result;
    }
    removeLastListener() {
        const result = super.removeLastListener();
        this.checkLastListener();
        return result;
    }
}
exports.GlobalEvent = GlobalEvent;

},{"jibo-typed-events":undefined}],179:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_typed_events_1 = require("jibo-typed-events");
const GlobalEvent_1 = require("./GlobalEvent");
const SharedGlobalEvents_1 = require("./SharedGlobalEvents");
const jibo_common_types_1 = require("jibo-common-types");
const jibo_client_framework_1 = require("jibo-client-framework");
const jetstream_client_1 = require("@jibo/jetstream-client");
var ListenResult = jetstream_client_1.types.ListenResult;
const Runtime_1 = require("../../Runtime");
const log_1 = require("./log");
class GlobalEvents extends jibo_typed_events_1.EventContainer {
    constructor() {
        super();
        this.log = log_1.default.createChild('Global');
        this.eventsWithHandlers = new Set();
        this.global = new jibo_typed_events_1.Event(`Any global event`);
        this.voiceStop = new GlobalEvent_1.GlobalEvent(jibo_common_types_1.GlobalCommand.STOP);
        this.help = new GlobalEvent_1.GlobalEvent(jibo_common_types_1.GlobalCommand.HELP);
        this.sleep = new GlobalEvent_1.GlobalEvent(jibo_common_types_1.GlobalCommand.SLEEP);
        this.pause = new GlobalEvent_1.GlobalEvent(jibo_common_types_1.GlobalCommand.PAUSE);
        this.volume = new GlobalEvent_1.GlobalEvent(jibo_common_types_1.GlobalCommand.VOLUME);
        this.whatCanIDo = new GlobalEvent_1.GlobalEvent(jibo_common_types_1.GlobalCommand.WHATCANIDO);
        this.holdOn = new GlobalEvent_1.GlobalEvent(jibo_common_types_1.GlobalCommand.HOLDON);
        this.overHere = new GlobalEvent_1.GlobalEvent(jibo_common_types_1.GlobalCommand.OVERHERE);
        this.skillLaunch = new jibo_typed_events_1.Event('skill-launch');
        this.skillRelaunch = new jibo_typed_events_1.Event('skill-relaunch');
        this.touchStop = new GlobalEvent_1.GlobalEvent('TOUCH');
        this.shared = new SharedGlobalEvents_1.default();
        this.voiceEvents = [
            this.help,
            this.voiceStop,
            this.sleep,
            this.pause,
            this.whatCanIDo,
            this.holdOn,
            this.volume,
            this.overHere
        ];
        this.setGlobalEvents();
        this.eventHandlers = {
            'global': this.onGlobal.bind(this),
            'skill-launch': this.onSkillLaunch.bind(this),
            'skill-relaunch': this.onSkillRelaunch.bind(this),
            'non-interrupting-global': this.onNonInterrupting.bind(this),
        };
        this._initializeTouchListener();
    }
    init(service, cb) {
        service.host = '127.0.0.1';
        const globalUrl = "ws:" + service.host + ":" + service.port + "/globals";
        this._httpInterface = "http://" + service.host + ":" + service.port;
        this._globalSocket = new jibo_client_framework_1.WSClient(globalUrl);
        this._globalSocket.on('error', (err) => {
            this.log.warn("error connecting to server ", err);
        });
        this._globalSocket.on('message', (data) => {
            this.onMessage(data);
        });
        this.shared.init();
        cb();
    }
    announceGlobalHandler(action, canHandle) {
        this.log.info(`setting ${action} to ${canHandle}`);
        let body = {
            "action": action,
            "canHandle": canHandle,
        };
        let request = new XMLHttpRequest();
        body = JSON.stringify(body);
        request.open("POST", this._httpInterface + '/global', true);
        request.send(body);
        return;
    }
    setGlobalEvents() {
        this.voiceEvents.forEach((globalEvent) => {
            globalEvent.setMode(jibo_typed_events_1.EmitterMode.LAST_HANDLER);
            globalEvent.onNoListeners(() => {
                this.announceGlobalHandler(jibo_common_types_1.GlobalCommand[globalEvent.name], false);
                this.eventsWithHandlers.delete(globalEvent.name);
            });
            globalEvent.onAddedListener(() => {
                this.log.info("adding listener for ", globalEvent.name);
                this.eventsWithHandlers.add(globalEvent.name);
                this.announceGlobalHandler(jibo_common_types_1.GlobalCommand[globalEvent.name], true);
            });
        });
    }
    onMessage(data) {
        if (data.status !== "OK") {
            this.log.warn("GlobalEvents returned status", data.status);
        }
        else {
            let handler = this.eventHandlers[data.message];
            if (handler) {
                handler(data);
            }
        }
    }
    onGlobal(data) {
        const result = ListenResult.fromJSON(data.result);
        this.log.info("global data from ssm", result);
        let action = result.nlu.intent;
        if (action.match(/^volume/)) {
            action = 'volume';
        }
        const event = this._getGlobalEvent(action);
        let analyticsAction;
        let analyticsData = {};
        action = action.toUpperCase();
        switch (action) {
            case jibo_common_types_1.GlobalCommand.STOP:
                analyticsAction = 'Stop';
                analyticsData.type = 'speech';
                break;
            case jibo_common_types_1.GlobalCommand.SLEEP:
                analyticsAction = 'Go To Sleep';
                break;
            case jibo_common_types_1.GlobalCommand.VOLUME:
                analyticsAction = 'Volume';
                analyticsData.type = 'speech';
                break;
        }
        if (analyticsAction) {
            Runtime_1.default.instance.analytics.track(`Global ${analyticsAction}`, analyticsData);
        }
        if (event) {
            this.log.info("accessing global", action, "command");
            event.emit(result);
            this.global.emit({
                name: action,
                data: result
            });
        }
        else {
            this.log.error("No global event found:", action);
        }
        return;
    }
    onSkillRelaunch(data) {
        const result = ListenResult.fromJSON(data.result);
        this.log.info("skill relaunch command from Global Service", result);
        let action = result.intent;
        let skill = result.match.skillID;
        if (result.transID && !result.match.onRobot) {
            result.cloudSkillResponse = Runtime_1.default.instance.jetstream.getCloudSkillResponse(result.transID);
        }
        let analyticsAction;
        let analyticsData = {};
        if (action) {
            action = action.toUpperCase();
            switch (action) {
                case jibo_common_types_1.GlobalCommand.HELP:
                case jibo_common_types_1.GlobalCommand.WHATCANIDO:
                    analyticsAction = 'WCYD';
                    break;
            }
        }
        if (!analyticsAction && (skill === '@be/main-menu')) {
            analyticsAction = 'Main Menu';
            analyticsData.type = 'speech';
        }
        if (analyticsAction) {
            Runtime_1.default.instance.analytics.track(`Global ${analyticsAction}`, analyticsData);
        }
        this.skillRelaunch.emit(result);
    }
    onNonInterrupting(data) {
        this.shared.nonInterruptingGlobal.emit();
    }
    onSkillLaunch(data) {
        this.skillLaunch.emit(ListenResult.fromJSON(data.result));
    }
    _getGlobalEvent(eventName) {
        let event = null;
        this.voiceEvents.forEach((globalEvent) => {
            if (globalEvent.name === eventName || globalEvent.name === jibo_common_types_1.GlobalCommandMap.get(eventName)) {
                event = globalEvent;
            }
        });
        return event;
    }
    _initializeTouchListener() {
        this.touchStop.setMode(jibo_typed_events_1.EmitterMode.LAST_HANDLER);
    }
}
exports.default = GlobalEvents;

},{"../../Runtime":1,"./GlobalEvent":178,"./SharedGlobalEvents":180,"./log":182,"@jibo/jetstream-client":undefined,"jibo-client-framework":undefined,"jibo-common-types":undefined,"jibo-typed-events":undefined}],180:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_typed_events_1 = require("jibo-typed-events");
const jetstream_client_1 = require("@jibo/jetstream-client");
const Runtime_1 = require("../../Runtime");
class SharedGlobalEvents {
    constructor() {
        this.hjOnly = new jibo_typed_events_1.Event('Received only a "hey jibo"');
        this.noGlobalMatch = new jibo_typed_events_1.Event('Parsed against global grammar and no result');
        this.nonInterruptingGlobal = new jibo_typed_events_1.Event('GL global command complete that did not interrupt state');
        this.screenGesture = new jibo_typed_events_1.Event('Touch manager received a screen gesture');
    }
    init() {
        const jetstream = Runtime_1.default.instance.jetstream;
        jetstream.events.globalTurnResult.on((result) => {
            if (result.status === jetstream_client_1.types.TurnResultType.TIMEOUT || result.status === jetstream_client_1.types.TurnResultType.FAILED) {
                this.hjOnly.emit(result);
                return;
            }
            if (result.status === jetstream_client_1.types.TurnResultType.SUCCEEDED) {
                const annotation = result.result.asr ? result.result.asr.annotation : null;
                if (annotation === jetstream.types.ASRAnnotation.GARBAGE ||
                    annotation === jetstream.types.ASRAnnotation.SOS_TIMEOUT ||
                    annotation === jetstream.types.ASRAnnotation.MAX_SPEECH_TIMEOUT) {
                    this.hjOnly.emit(result);
                    return;
                }
                if ((result.result.state === jetstream.types.ListenResultState.noMatch) ||
                    (!result.result.match && result.result.nlu.rules.indexOf('launch') >= 0)) {
                    this.noGlobalMatch.emit(result);
                    return;
                }
            }
        });
        jetstream.events.hjOnly.on(() => {
            this.hjOnly.emit();
        });
    }
}
exports.default = SharedGlobalEvents;

},{"../../Runtime":1,"@jibo/jetstream-client":undefined,"jibo-typed-events":undefined}],181:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const GlobalEvents_1 = require("./GlobalEvents");
exports.default = {
    GlobalEvents: GlobalEvents_1.default
};

},{"./GlobalEvents":179}],182:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log_1 = require("../../log");
exports.default = log_1.default.createChild('Events');

},{"../../log":75}],183:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const SessionManager_1 = require("./SessionManager");
const Media_1 = require("./media/Media");
const GlobalEvents_1 = require("./events/GlobalEvents");
const kb = require("jibo-kb");
const RemoteService_1 = require("./remote/RemoteService");
exports.default = {
    GlobalEvents: GlobalEvents_1.default,
    SessionManager: SessionManager_1.default,
    Media: Media_1.default,
    kb,
    RemoteService: RemoteService_1.default
};

},{"./SessionManager":177,"./events/GlobalEvents":179,"./media/Media":184,"./remote/RemoteService":190,"jibo-kb":undefined}],184:[function(require,module,exports){
"use strict";
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;
};
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../../Runtime");
const jibo_service_clients_1 = require("jibo-service-clients");
const MediaModel_1 = require("./MediaModel");
const MediaNode_1 = require("./MediaNode");
const decorators_1 = require("../../utils/decorators");
var CameraID = jibo_service_clients_1.media.CameraID;
exports.CameraID = CameraID;
var PhotoType = jibo_service_clients_1.media.PhotoType;
exports.PhotoType = PhotoType;
const log_1 = require("./log");
var FilterFlipMethod;
(function (FilterFlipMethod) {
    FilterFlipMethod[FilterFlipMethod["IDENTITY"] = 0] = "IDENTITY";
    FilterFlipMethod[FilterFlipMethod["HORIZONTAL"] = 1] = "HORIZONTAL";
    FilterFlipMethod[FilterFlipMethod["VERTICAL"] = 2] = "VERTICAL";
})(FilterFlipMethod = exports.FilterFlipMethod || (exports.FilterFlipMethod = {}));
var ThumbnailType;
(function (ThumbnailType) {
    ThumbnailType["thumb"] = "thumb";
    ThumbnailType["thumb_robot"] = "thumb_robot";
})(ThumbnailType = exports.ThumbnailType || (exports.ThumbnailType = {}));
class Media {
    constructor() {
        this.isInitialized = false;
        this.CameraID = CameraID;
        this.PhotoType = PhotoType;
        this.ThumbnailType = ThumbnailType;
        this.mediaService = jibo_service_clients_1.media;
        this.mediaManagerService = jibo_service_clients_1.mediaManager;
    }
    init(callback) {
        let records = Runtime_1.default.instance.records;
        for (let i = 0; i < records.length; i++) {
            if (records[i].name === 'media-proxy') {
                let record = records[i];
                this.proxyUrl = `http://${record.host}:${record.port}`;
                break;
            }
        }
        if (this.proxyUrl) {
            log_1.default.info('proxyUrl', this.proxyUrl);
        }
        else {
            log_1.default.error('could not find media-manager service');
        }
        let kb = Runtime_1.default.instance.kb;
        kb.registerModelClass('jibo/media', MediaModel_1.default);
        kb.registerNodeClass('media', MediaNode_1.default, 'jibo/media');
        kb.media = kb.createModel('/jibo/media');
        this.isInitialized = true;
        process.nextTick(callback);
    }
    takePhoto(params, callback) {
        if (typeof params === 'function') {
            callback = params;
            params = {};
        }
        let camera = params.camera;
        if (camera !== undefined && camera !== CameraID.LEFT && camera !== CameraID.RIGHT) {
            camera = undefined;
        }
        if (camera === undefined) {
            camera = CameraID.RIGHT;
        }
        let photoType = params.photoType;
        if (photoType !== undefined && (params.photoType < PhotoType.DEBUG || params.photoType > PhotoType.FOUR_MP)) {
            photoType = undefined;
        }
        if (photoType === undefined) {
            params.photoType = PhotoType.SNAP;
        }
        let undistort = params.undistort;
        if (undistort === undefined) {
            undistort = true;
        }
        else {
            undistort = !!undistort;
        }
        let flip = params.flip;
        if (flip === undefined) {
            flip = true;
        }
        else {
            flip = !!flip;
        }
        let colorCorrection = params.colorCorrection;
        if (colorCorrection === undefined) {
            colorCorrection = true;
        }
        else {
            colorCorrection = !!colorCorrection;
        }
        let filters = [];
        if (undistort) {
            filters.push({
                kind: 'undistort',
                config: {}
            });
        }
        if (flip) {
            filters.push({
                kind: 'flip',
                config: {
                    method: FilterFlipMethod.HORIZONTAL
                }
            });
        }
        if (colorCorrection) {
            filters.push({
                'kind': 'brightness_contrast',
                'config': {
                    'brightness': 0.08,
                    'contrast': -0.1
                }
            });
            filters.push({
                'kind': 'vibrance',
                'config': {
                    'amount': 0.1
                }
            });
            filters.push({
                'kind': 'hue_saturation',
                'config': {
                    'hue': 0,
                    'saturation': 0.05
                }
            });
            filters.push({
                'kind': 'rgb_curve',
                'config': {
                    'red': [[0.1, 0], [0.5, 0.48], [1, 1]],
                    'blue': [[0.1, 0], [0.5, 0.51], [1, 1]],
                    'green': [[0.1, 0], [0.5, 0.5], [1, 1]]
                }
            });
        }
        if (params.filters) {
            filters = filters.concat(params.filters);
        }
        let store = false;
        this.mediaService.takePhoto(camera, photoType, filters, store, (err, data) => {
            if (err) {
                callback(err);
            }
            else {
                let response = {
                    id: data.id,
                    url: this.getPreviewUrl(data.id)
                };
                callback(null, response);
            }
        });
    }
    storePhoto(one, two, three) {
        let id;
        let buffer;
        let params;
        let callback;
        if (typeof one === 'string' || one instanceof Buffer) {
            if (one instanceof Buffer) {
                buffer = one;
            }
            else {
                id = one;
            }
            if (typeof two === 'function') {
                params = {};
                callback = two;
            }
            else {
                params = two;
                callback = three;
            }
        }
        else {
            params = one;
            callback = two;
        }
        id = id || params.id;
        buffer = buffer || params.buffer;
        if ((!buffer && !id) || (id && buffer)) {
            throw new Error('storePhoto requires either id or buffer');
        }
        let thumbnails = {};
        thumbnails[ThumbnailType.thumb] = [720, 405];
        thumbnails[ThumbnailType.thumb_robot] = [330, 330];
        let timer = performance.now();
        this.mediaService.storePhoto(buffer, id, thumbnails, (err, data) => {
            if (err) {
                callback(err);
            }
            else {
                Runtime_1.default.instance.kb.media.storePhoto(data, (err, response) => {
                    let elapsed = Math.round(performance.now() - timer);
                    console.warn('storePhoto total time took ' + elapsed + 'ms');
                    callback(err, response);
                });
            }
        });
    }
    deletePhoto(id, callback) {
        let immediate = true;
        let deleteLocal = true;
        let deleteRemote = false;
        let mediaType = this.mediaManagerService.MediaType.image;
        let timer = performance.now();
        this.mediaManagerService.delete(id, immediate, deleteLocal, deleteRemote, mediaType, (err) => {
            if (err) {
                log_1.default.iferr(err);
                callback(err);
            }
            else {
                Runtime_1.default.instance.kb.media.deletePhoto(id, (err) => {
                    let elapsed = Math.round(performance.now() - timer);
                    log_1.default.info('local deletePhoto took ' + elapsed + 'ms');
                    callback();
                });
            }
        });
    }
    getPhoto(id, callback) {
        let url = this.getUrl(id);
        Runtime_1.default.instance.loader.load({
            format: 'image',
            src: url,
            type: 'texture'
        }, callback);
    }
    getUrl(contentId) {
        return `${this.proxyUrl}/proxy/media/photo/get?id=${contentId}`;
    }
    getPreviewUrl(id) {
        return this.mediaService.getPreviewUrl(id);
    }
    setViewfinder(one, two, three) {
        let enable;
        let params;
        let callback;
        if (one !== null && typeof one === 'object') {
            params = one;
            callback = two;
            enable = params.enable;
        }
        else if (!three && typeof two === 'function') {
            enable = one;
            callback = two;
            params = {};
        }
        else {
            enable = one;
            params = two;
            callback = three;
        }
        let assignIfDefined = (source, target, keys) => {
            keys.forEach((key) => {
                if (source[key] !== undefined) {
                    target[key] = source[key];
                }
            });
        };
        let data = { enable: enable };
        assignIfDefined(params, data, ['camera', 'height', 'width', 'x', 'y']);
        this.mediaService.setViewfinder(data, callback);
    }
    getViewfinder(callback) {
        this.mediaService.getViewfinder(callback);
    }
}
__decorate([
    decorators_1.promisify,
    decorators_1.isInitialized
], Media.prototype, "takePhoto", null);
__decorate([
    decorators_1.promisify,
    decorators_1.isInitialized
], Media.prototype, "storePhoto", null);
__decorate([
    decorators_1.promisify
], Media.prototype, "deletePhoto", null);
__decorate([
    decorators_1.promisify,
    decorators_1.isInitialized
], Media.prototype, "getPhoto", null);
__decorate([
    decorators_1.promisify,
    decorators_1.isInitialized
], Media.prototype, "setViewfinder", null);
__decorate([
    decorators_1.promisify,
    decorators_1.isInitialized
], Media.prototype, "getViewfinder", null);
exports.Media = Media;
exports.default = Media;

},{"../../Runtime":1,"../../utils/decorators":204,"./MediaModel":185,"./MediaNode":187,"./log":188,"jibo-service-clients":undefined}],185:[function(require,module,exports){
"use strict";
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;
};
Object.defineProperty(exports, "__esModule", { value: true });
const axios_1 = require("axios");
const Runtime_1 = require("../../Runtime");
const decorators_1 = require("../../utils/decorators");
const MediaNode_1 = require("./MediaNode");
const Media_1 = require("./Media");
var Media_2 = require("./Media");
exports.ThumbnailType = Media_2.ThumbnailType;
const jibo_service_clients_1 = require("jibo-service-clients");
var MediaType = jibo_service_clients_1.mediaManager.MediaType;
const jibo_kb_1 = require("jibo-kb");
const MediaModelEvents_1 = require("./MediaModelEvents");
const jibo_client_framework_1 = require("jibo-client-framework");
const log_1 = require("./log");
const log = log_1.default.createChild('Model');
class MediaModel extends jibo_kb_1.Model {
    constructor(kbNames, httpUrl = null) {
        super(kbNames, httpUrl);
        this.MediaNode = MediaNode_1.default;
        this.MediaType = MediaType;
        this.ThumbnailType = Media_1.ThumbnailType;
        this.events = new MediaModelEvents_1.default();
        this._listenForWSMessages();
    }
    static _processError(err) {
        if (err.response) {
            let description = `HTTP Error Code ${err.response.status}`;
            if (err.response.data) {
                description += err.response.data;
            }
            return new Error(description);
        }
        else {
            return new Error(err.request
                ? 'No response received'
                : 'Unknown error');
        }
    }
    loadMedia(callback) {
        this.loadMediaAll((err, media) => {
            if (!err) {
                callback(null, this._onlyNotDeleted(media));
            }
            else {
                callback(err);
            }
        });
    }
    loadMediaAll(callback) {
        this.loadRoot(null, (err, rootNode) => {
            log.iferr(err, 'loadRoot');
            if (!err && rootNode) {
                let mediaIds = rootNode.getEdges('media');
                this.load(mediaIds, (err, nodes) => {
                    log.iferr(err, 'load');
                    callback(err, nodes);
                });
            }
            else {
                callback(err);
            }
        });
    }
    loadThumbnail(mediaNode, two, three) {
        let type;
        let callback;
        if (typeof two === 'function') {
            type = null;
            callback = two;
        }
        else {
            type = two;
            callback = three;
        }
        type = type || Media_1.ThumbnailType.thumb_robot;
        let thumbId = mediaNode.getThumbnailId(type);
        this.load(thumbId, callback);
    }
    getThumbnailUrl(mediaNode, type) {
        type = type || Media_1.ThumbnailType.thumb_robot;
        let thumbId = mediaNode.getThumbnailId(type);
        return Runtime_1.default.instance.media.getUrl(thumbId);
    }
    downloadThumbnails(ids, callback) {
        let url = `${this.httpUrl}/v1/media/downloadThumbnails`;
        let params = {
            ids: ids,
            type: 'image'
        };
        axios_1.default.post(url, params)
            .then(res => callback && callback(null), (err) => {
            log.error('request.post', url, err);
            if (callback) {
                callback(MediaModel._processError(err));
            }
        });
    }
    downloadPhoto(id, callback) {
        let url = `${this.httpUrl}/v1/media/downloadPhoto`;
        let params = {
            id: id,
            type: 'image'
        };
        axios_1.default.post(url, params).then(res => callback && callback(null), (err) => {
            log.error('request.post', url, err);
            if (callback) {
                callback(MediaModel._processError(err));
            }
        });
    }
    storePhoto(data, callback) {
        let url = `${this.httpUrl}/v1/media/storePhoto`;
        let params = data;
        axios_1.default.post(url, params).then(res => callback && callback(null, res.data), (err) => {
            log.error('request.post', url, err);
            if (callback) {
                callback(MediaModel._processError(err));
            }
        });
    }
    deletePhoto(id, callback) {
        let url = `${this.httpUrl}/v1/media/deletePhoto`;
        let params = {
            id: id
        };
        axios_1.default.post(url, params).then(res => callback && callback(null), (err) => {
            log.error('request.post', url, err);
            if (callback) {
                callback(MediaModel._processError(err));
            }
        });
    }
    _listenForWSMessages() {
        this._wsClient = new jibo_client_framework_1.WSClient(this.httpUrl);
        this._wsClient.on('message', this._wsMessageReceived.bind(this));
    }
    _wsMessageReceived(message) {
        switch (message) {
            case 'MediaListChanged':
                log.info('MediaModel: received MediaListChanged event; emitting MediaModelEvents.mediaListChanged');
                this.events.mediaListChanged.emit();
                break;
        }
    }
    _onlyNotDeleted(media) {
        return media.filter((media) => { return media && !media.data.isDeleted; });
    }
}
__decorate([
    decorators_1.promisify
], MediaModel.prototype, "loadMedia", null);
__decorate([
    decorators_1.promisify
], MediaModel.prototype, "loadMediaAll", null);
__decorate([
    decorators_1.promisify
], MediaModel.prototype, "loadThumbnail", null);
__decorate([
    decorators_1.promisify
], MediaModel.prototype, "downloadThumbnails", null);
__decorate([
    decorators_1.promisify
], MediaModel.prototype, "downloadPhoto", null);
__decorate([
    decorators_1.promisify
], MediaModel.prototype, "storePhoto", null);
__decorate([
    decorators_1.promisify
], MediaModel.prototype, "deletePhoto", null);
exports.default = MediaModel;

},{"../../Runtime":1,"../../utils/decorators":204,"./Media":184,"./MediaModelEvents":186,"./MediaNode":187,"./log":188,"axios":undefined,"jibo-client-framework":undefined,"jibo-kb":undefined,"jibo-service-clients":undefined}],186:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_typed_events_1 = require("jibo-typed-events");
class MediaModelEvents extends jibo_typed_events_1.EventContainer {
    constructor() {
        super(...arguments);
        this.mediaListChanged = new jibo_typed_events_1.Event('Media list has changed');
    }
}
exports.default = MediaModelEvents;

},{"jibo-typed-events":undefined}],187:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_kb_1 = require("jibo-kb");
const Media_1 = require("./Media");
var Media_2 = require("./Media");
exports.ThumbnailType = Media_2.ThumbnailType;
class MediaNode extends jibo_kb_1.Node {
    get id() {
        return this._id;
    }
    get loopId() {
        return this.data.loopId;
    }
    get url() {
        return this.data.url;
    }
    getThumbnailId(type) {
        type = type || Media_1.ThumbnailType.thumb_robot;
        return this.getEdges(Media_1.ThumbnailType[type])[0];
    }
}
exports.default = MediaNode;

},{"./Media":184,"jibo-kb":undefined}],188:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log_1 = require("../../log");
exports.default = log_1.default.createChild('Media');

},{"../../log":75}],189:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
var IncomingTypes;
(function (IncomingTypes) {
    IncomingTypes["CONNECTED"] = "connected";
    IncomingTypes["DISCONNECTED"] = "disconnected";
    IncomingTypes["SEND_ERROR"] = "sendError";
})(IncomingTypes = exports.IncomingTypes || (exports.IncomingTypes = {}));

},{}],190:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_client_framework_1 = require("jibo-client-framework");
const jibo_typed_events_1 = require("jibo-typed-events");
const jibo_command_library_1 = require("jibo-command-library");
const jibo_command_protocol_1 = require("jibo-command-protocol");
const Runtime_1 = require("../../Runtime");
const timer = require("application-metrics");
const Messages_1 = require("./Messages");
const log_1 = require("../../log");
const log = log_1.default.createChild('RemoteService');
exports.REMOTE_SESSION = 'remote';
class RemoteService {
    constructor() {
        this._blockCloseResponse = false;
        this.onMessageIn = this.onMessageIn.bind(this);
        this.onMessageOut = this.onMessageOut.bind(this);
        this.onConnectionEnded = this.onConnectionEnded.bind(this);
        this._remoteSocket = null;
        jibo_command_library_1.default.createInstance(Runtime_1.default.instance);
        this._remoteConnection = this.createCommandConnector(exports.REMOTE_SESSION, false);
        this.sessionDiscarded = new jibo_typed_events_1.Event('Remote session closed');
    }
    init(service, cb) {
        service.host = '127.0.0.1';
        const url = "ws:" + service.host + ":" + service.port;
        this._remoteSocket = new jibo_client_framework_1.WSClient(url);
        this._remoteSocket.on('error', (err) => {
            log.warn("error connecting to server ", err);
        });
        this._remoteSocket.on('message', this.onMessageIn);
        cb();
    }
    createCommandConnector(id, startReady = true) {
        if (jibo_command_library_1.default.instance) {
            return jibo_command_library_1.default.instance.createCommandConnector(id, startReady);
        }
        else {
            log.warn('createCommandConnector : CommandLibrary.instance is not yet defined');
            return null;
        }
    }
    ready() {
        this._remoteConnection.ready(true);
        log.debug('Command Performance : time to remote skill ready : ' + timer.stop('onMessageIn::CONNECTED') + 'ms');
    }
    closeConnection(code = jibo_command_protocol_1.DisconnectCode.RobotError) {
        if (!this._remoteConnection.disconnect(code)) {
            this.onConnectionEnded(code);
        }
        log.info('disconnected with code', code);
    }
    handleVideo(assetUrl, videoType) {
        const message = {
            type: 'message',
            status: 'handleAsset',
            asset: {
                assetUrl: assetUrl,
                type: 'video',
                videoType
            }
        };
        this.onMessageOut(message);
    }
    handlePhoto(assetUrl, photoUrl) {
        const message = {
            type: 'message',
            status: 'handleAsset',
            asset: {
                assetUrl: assetUrl,
                type: 'photo',
                photoUrl: photoUrl
            }
        };
        this.onMessageOut(message);
    }
    cancelAsset(assetUrl) {
        const message = {
            type: 'message',
            status: 'cancelAsset',
            asset: {
                assetUrl: assetUrl
            }
        };
        this.onMessageOut(message);
    }
    onMessageIn(message) {
        let data;
        try {
            if (typeof message === 'string') {
                data = JSON.parse(message);
            }
            else {
                data = message;
            }
        }
        catch (e) {
            log.warn('Unable to parse json message from SSM Remote service');
            return;
        }
        this._blockCloseResponse = true;
        if (data.type === 'message') {
            const message = data;
            switch (message.status) {
                case Messages_1.IncomingTypes.CONNECTED:
                    timer.start('onMessageIn::CONNECTED');
                    this.connectToCommandLibrary(message);
                    break;
                case Messages_1.IncomingTypes.DISCONNECTED:
                    if (!message.wasError) {
                        this.closeConnection();
                    }
                    else {
                        this._remoteConnection.awaitReconnect();
                    }
                    break;
                case Messages_1.IncomingTypes.SEND_ERROR:
                    this._remoteConnection.responseFailed(message.message);
                    break;
            }
        }
        else {
            this._remoteConnection.sendMessage(data);
        }
        this._blockCloseResponse = false;
    }
    connectToCommandLibrary(message) {
        log.info('sendConnectionEvent message:', message);
        let aco;
        if (message && message.appData && message.appData.aco) {
            aco = message.appData.aco;
        }
        else {
            log.warn('No ACO sent with connection message, using a default ACO');
            aco = {
                version: jibo_command_protocol_1.ProtocolVersions.v1,
                sourceId: 'testApp',
                commandSet: [
                    jibo_command_protocol_1.CommandTypes.GetConfig,
                    jibo_command_protocol_1.CommandTypes.LookAt,
                    jibo_command_protocol_1.CommandTypes.Say,
                    jibo_command_protocol_1.CommandTypes.TakePhoto,
                    jibo_command_protocol_1.CommandTypes.Video,
                ],
                streamSet: [
                    jibo_command_protocol_1.StreamTypes.Entity,
                    jibo_command_protocol_1.StreamTypes.Motion,
                ],
                keepAliveTimeout: 10 * 1000,
                recoveryTimeout: 20 * 1000,
                remoteConfig: {
                    hideVisualCue: false,
                    inactivityTimeout: 10 * 60 * 1000
                }
            };
        }
        log.info('sendConnectionEvent aco:', aco);
        this._remoteConnection.connect(aco, this.onMessageOut, this.onConnectionEnded);
        let intent = aco.remoteConfig.hideVisualCue ? 'silentRemote' : 'normalRemote';
        if (!this._remoteConnection.isReady) {
            log.info('connected. Request skill redirect to @be/remote');
            const parseResults = new Runtime_1.default.instance.jetstream.types.ListenResult({
                text: '',
                confidence: 1
            }, {
                entities: {},
                rules: null,
                intent: intent,
            }, {
                skillID: '@be/remote',
                onRobot: true
            });
            const launchMessage = {
                type: 'message',
                status: 'launchSkill',
                result: parseResults
            };
            this.onMessageOut(launchMessage);
        }
    }
    onMessageOut(message) {
        if (this._remoteSocket) {
            this._remoteSocket.send(JSON.stringify(message));
        }
        else {
            log.warn('onMessageOut : remote socket is null, cannot send message');
        }
    }
    onConnectionEnded(code = jibo_command_protocol_1.DisconnectCode.RobotError) {
        this._remoteConnection.ready(false);
        this.sessionDiscarded.emit();
        if (!this._blockCloseResponse) {
            const reason = jibo_command_protocol_1.DisconnectReason[code];
            const message = {
                type: 'message',
                status: 'close',
                code,
                reason
            };
            this.onMessageOut(message);
        }
    }
}
exports.default = RemoteService;

},{"../../Runtime":1,"../../log":75,"./Messages":189,"application-metrics":undefined,"jibo-client-framework":undefined,"jibo-command-library":undefined,"jibo-command-protocol":undefined,"jibo-typed-events":undefined}],191:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class ChainBuilder {
    constructor(_context) {
        this._context = _context;
        this._firstNode = null;
        this._lastNode = null;
        this._nodes = {};
    }
    destroy() {
        this._nodes = null;
        this._context = null;
        this._firstNode = null;
        this._lastNode = null;
    }
    nodes() {
        return this._nodes;
    }
    first() {
        return this._firstNode;
    }
    last() {
        return this._lastNode;
    }
    _addNode(node, properties) {
        const lastIsBufferSource = this._lastNode && ('playbackRate' in this._lastNode);
        if (lastIsBufferSource) {
            this._bufferSourceDst = node;
        }
        if (this._lastNode) {
            this._lastNode.connect(node);
        }
        if (!this._firstNode) {
            this._firstNode = node;
        }
        this._lastNode = node;
        for (let property in properties) {
            node[property] = properties[property];
        }
        return this;
    }
    cloneBufferSource() {
        console.assert(this._nodes.bufferSource, "No buffersource presents. Add one.");
        const orig = this._nodes.bufferSource;
        const clone = this._context.createBufferSource();
        clone.buffer = orig.buffer;
        clone.playbackRate.value = orig.playbackRate.value;
        clone.loop = orig.loop;
        clone.connect(this._bufferSourceDst);
        return clone;
    }
    bufferSource(properties) {
        const node = this._context.createBufferSource();
        this._nodes.bufferSource = node;
        return this._addNode(node, properties);
    }
    panner(properties) {
        const node = this._context.createStereoPanner();
        this._nodes.panner = node;
        return this._addNode(node, properties);
    }
    analyser(properties) {
        const node = this._context.createAnalyser();
        this._nodes.analyser = node;
        return this._addNode(node, properties);
    }
    gainNode(properties) {
        const node = this._context.createGain();
        this._nodes.gainNode = node;
        return this._addNode(node, properties);
    }
}
exports.default = ChainBuilder;

},{}],192:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const ChainBuilder_1 = require("./ChainBuilder");
const SoundInstance_1 = require("./SoundInstance");
const Runtime_1 = require("../Runtime");
const jibo_plugins_1 = require("jibo-plugins");
const path = require("path");
const log_1 = require("./log");
class Sound {
    constructor(context, options) {
        if (typeof options === "string" || options instanceof ArrayBuffer) {
            options = { src: options };
        }
        else if (options instanceof ArrayBuffer) {
            options = { srcBuffer: options };
        }
        options = Object.assign({
            autoPlay: false,
            block: false,
            src: null,
            preload: false,
            volume: 1,
            panning: 0,
            complete: null,
            loaded: null,
            loop: false,
            useXHR: false
        }, options || {});
        this._context = context;
        this._ctx = this._context.context;
        this._chain = new ChainBuilder_1.default(this._ctx)
            .bufferSource()
            .gainNode()
            .analyser()
            .panner();
        this.isLoaded = false;
        this.isPlaying = false;
        this.autoPlay = options.autoPlay;
        this.block = options.block;
        this.preload = options.preload;
        this.complete = options.complete;
        this.loaded = options.loaded;
        this.src = options.src;
        this.srcBuffer = options.srcBuffer;
        this.useXHR = options.useXHR;
        this._instances = [];
        this._chain.last().connect(this._context._entryNode());
        this._source = this._chain.nodes().bufferSource;
        this._gainNode = this._chain.nodes().gainNode;
        this._analyser = this._chain.nodes().analyser;
        this._panner = this._chain.nodes().panner;
        console.assert(this._source, "No bufferSource: not yet supported");
        console.assert(this._gainNode, "No gainNode: not yet supported");
        console.assert(this._analyser, "No analyser: not yet supported");
        console.assert(this._panner, "No panner: not yet supported");
        this.volume = options.volume;
        this.panning = options.panning;
        this.loop = options.loop;
        if (this.preload) {
            this._beginPreload();
        }
    }
    _beginPreload() {
        if (this.src) {
            this.useXHR ? this.loadUrl() : this.loadPath();
        }
        else if (this.srcBuffer) {
            this.decode(this.srcBuffer);
        }
        else if (this.loaded) {
            this.loaded(new Error("sound.src or sound.srcBuffer must be set"));
        }
        else {
            log_1.default.warn('sound.src or sound.srcBuffer must be set');
        }
    }
    destroy() {
        this._chain.last().disconnect();
        this._chain.destroy();
        this._chain = null;
        this._context = null;
        this._ctx = null;
        this._source = null;
        this._removeInstances();
        this._instances = null;
    }
    get isPlayable() {
        return this.isLoaded && !!this._source && !!this._source.buffer;
    }
    get nodes() {
        return this._chain.nodes();
    }
    get volume() {
        return this._gainNode.gain.value;
    }
    set volume(volume) {
        this._gainNode.gain.value = volume;
    }
    get loop() {
        return this._source.loop;
    }
    set loop(loop) {
        this._source.loop = !!loop;
    }
    get buffer() {
        return this._source.buffer;
    }
    set buffer(buffer) {
        this._source.buffer = buffer;
    }
    get panning() {
        return this._panner.pan;
    }
    set panning(pan) {
        this._panner.pan.value = pan;
    }
    get instances() {
        return this._instances;
    }
    play(options) {
        if (typeof options === "function") {
            options = { complete: options };
        }
        options = Object.assign({
            complete: null,
            loaded: null,
            offset: 0
        }, options || {});
        if (!this.isPlayable) {
            this.autoPlay = true;
            if (!this.isLoaded) {
                const loaded = options.loaded;
                if (loaded) {
                    this.loaded = loaded;
                }
                this._beginPreload();
            }
            return;
        }
        if (this.block) {
            this._removeInstances();
        }
        const instance = SoundInstance_1.default.create(this._chain);
        this._instances.push(instance);
        this.isPlaying = true;
        instance.once('complete', () => {
            this._onComplete(instance);
            if (options.complete) {
                options.complete(this);
            }
        });
        instance.play(options.offset);
        return instance;
    }
    _onComplete(instance) {
        if (this._instances) {
            const index = this._instances.indexOf(instance);
            if (index > -1) {
                this._instances.splice(index, 1);
            }
            this.isPlaying = this._instances.length > 0;
        }
        instance.destroy();
    }
    stop() {
        if (!this.isPlayable) {
            this.autoPlay = false;
            return this;
        }
        this.isPlaying = false;
        this._instances.forEach(function (instance) {
            instance.stop();
        });
        return this;
    }
    pause() {
        this._instances.forEach(function (instance) {
            instance.paused = true;
        });
        this.isPlaying = false;
        return this;
    }
    resume() {
        this._instances.forEach(function (instance) {
            instance.paused = false;
        });
        this.isPlaying = this._instances.length > 0;
        return this;
    }
    _removeInstances() {
        this._instances.forEach(function (instance) {
            instance.destroy();
        });
        this._instances.length = 0;
    }
    loadUrl() {
        const request = new XMLHttpRequest();
        let src = this.src;
        if (!jibo_plugins_1.PathUtils.isURL(src)) {
            src = Runtime_1.default.instance.sound.baseUrl + src;
        }
        request.open('GET', src, true);
        request.responseType = 'arraybuffer';
        request.onload = () => {
            this.isLoaded = true;
            this.srcBuffer = request.response;
            this.decode(request.response);
        };
        request.send();
    }
    loadPath() {
        const fs = require('fs');
        let src = this.src;
        if (!path.isAbsolute(src)) {
            src = jibo_plugins_1.PathUtils.getAssetUri(src, undefined, Runtime_1.default.instance.sound.basePath);
        }
        fs.readFile(src, (err, data) => {
            if (err) {
                log_1.default.error('problem reading file', err);
                if (this.loaded) {
                    this.loaded(new Error(`File not found ${this.src}`));
                }
                return;
            }
            const arrayBuffer = new ArrayBuffer(data.length);
            const view = new Uint8Array(arrayBuffer);
            for (let i = 0; i < data.length; ++i) {
                view[i] = data[i];
            }
            this.decode(arrayBuffer);
        });
    }
    decode(arrayBuffer) {
        this._ctx.decodeAudioData(arrayBuffer)
            .then((buffer) => {
            this.isLoaded = true;
            this.buffer = buffer;
            if (this.loaded) {
                this.loaded(null, this);
            }
            if (this.autoPlay) {
                this.play(this.complete);
            }
        }, (err) => {
            if (this.loaded) {
                this.loaded(new Error(`Unable to decode file ${err}`));
            }
        });
    }
}
exports.default = Sound;

},{"../Runtime":1,"./ChainBuilder":191,"./SoundInstance":194,"./log":198,"fs":undefined,"jibo-plugins":undefined,"path":undefined}],193:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class SoundContext {
    constructor() {
        this._ctx = new AudioContext();
        this._gainNode = this._ctx.createGain();
        this._compressor = this._ctx.createDynamicsCompressor();
        this._gainNode.connect(this._compressor);
        this._compressor.connect(this._ctx.destination);
        this.volume = 1;
        this.muted = false;
        this.paused = false;
    }
    destroy() {
        this._ctx = null;
        this._gainNode = null;
        this._compressor = null;
    }
    get context() {
        return this._ctx;
    }
    get muted() {
        return this._muted;
    }
    set muted(muted) {
        this._muted = !!muted;
        this._gainNode.gain.value = this._muted ? 0 : this._volume;
    }
    set volume(volume) {
        this._volume = volume;
        if (!this._muted) {
            this._gainNode.gain.value = this._volume;
        }
    }
    get volume() {
        return this._volume;
    }
    set paused(paused) {
        if (paused && this._ctx.state === 'running') {
            this._ctx.suspend();
        }
        else if (!paused && this._ctx.state === 'suspended') {
            this._ctx.resume();
        }
        this._paused = paused;
    }
    get paused() {
        return this._paused;
    }
    _entryNode() {
        return this._gainNode;
    }
    toggleMute() {
        this.muted = !this.muted;
        return this._muted;
    }
}
exports.default = SoundContext;

},{}],194:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const events_1 = require("events");
let id = 0;
class SoundInstance extends events_1.EventEmitter {
    constructor(chain) {
        super();
        this.id = id++;
        this._chain = null;
        this._startTime = 0;
        this._paused = false;
        this._currentPosition = 0;
        this.init(chain);
    }
    static create(chain) {
        if (SoundInstance._pool.length > 0) {
            let sound = SoundInstance._pool.pop();
            sound.init(chain);
            return sound;
        }
        else {
            return new SoundInstance(chain);
        }
    }
    init(chain) {
        this._chain = chain;
    }
    stop() {
        if (this._source) {
            this._source.onended = null;
            this._source.stop();
            this._source = null;
        }
    }
    play(offset) {
        this._source = this._chain.cloneBufferSource();
        this._startTime = Date.now();
        this._source.onended = this._onComplete.bind(this);
        this._source.start(0, offset || 0);
    }
    get paused() {
        return this._paused;
    }
    set paused(paused) {
        if (paused !== this._paused) {
            this._paused = paused;
            if (paused) {
                this.stop();
                this._currentPosition = Date.now() - this._startTime;
            }
            else {
                this.play(this._currentPosition / 1000);
            }
        }
    }
    _onComplete() {
        if (this._source) {
            this._source.onended = null;
        }
        this._source = null;
        this.emit('complete', this);
    }
    destroy() {
        this.removeAllListeners('complete');
        this.stop();
        if (this._source) {
            this._source.onended = null;
        }
        this._source = null;
        this._chain = null;
        this._startTime = 0;
        this._paused = false;
        this._currentPosition = 0;
        if (SoundInstance._pool.indexOf(this) < 0) {
            SoundInstance._pool.push(this);
        }
    }
    toString() {
        return '[SoundInstance id=' + this.id + ']';
    }
}
SoundInstance._pool = [];
exports.default = SoundInstance;

},{"events":undefined}],195:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const SoundContext_1 = require("./SoundContext");
const Sound_1 = require("./Sound");
const SoundInstance_1 = require("./SoundInstance");
const SoundUtils_1 = require("./SoundUtils");
const SoundTask_1 = require("./tasks/SoundTask");
const Runtime_1 = require("../Runtime");
const jibo_log_1 = require("jibo-log");
class SoundPlugin {
    constructor() {
        this.basePath = '';
        this.baseUrl = '';
        this._context = new SoundContext_1.default();
        this._sounds = {};
        this.SoundUtils = SoundUtils_1.default;
        this.Sound = Sound_1.default;
        this.SoundInstance = SoundInstance_1.default;
        Runtime_1.default.instance.loader.register(SoundTask_1.default, 50);
        this.log = new jibo_log_1.Log('SoundPlugin');
    }
    init(done) {
        done();
    }
    get context() {
        return this._context;
    }
    add(alias, options) {
        if (this._sounds[alias]) {
            this.log.warn(`Sound with alias ${alias} already exists.`);
        }
        const sound = this._sounds[alias] = new Sound_1.default(this.context, options);
        return sound;
    }
    addMap(map, globalOptions) {
        let results = {};
        for (let a in map) {
            let options;
            if (typeof map[a] === "string" || map[a] instanceof ArrayBuffer) {
                options = { src: map[a] };
            }
            else {
                options = map[a];
            }
            results[a] = this.add(a, Object.assign(options, globalOptions || {}));
        }
        return results;
    }
    remove(alias) {
        if (this.exists(alias, true)) {
            this._sounds[alias].destroy();
        }
        delete this._sounds[alias];
        return this;
    }
    pauseAll() {
        this._context.paused = true;
        return this;
    }
    resumeAll() {
        this._context.paused = false;
        return this;
    }
    muteAll() {
        this._context.muted = true;
        return this;
    }
    unmuteAll() {
        this._context.muted = false;
        return this;
    }
    removeAll() {
        for (let alias in this._sounds) {
            this._sounds[alias].destroy();
        }
        return this;
    }
    stopAll() {
        for (let alias in this._sounds) {
            this._sounds[alias].stop();
        }
        return this;
    }
    exists(alias, assert = false) {
        const exists = !!this._sounds[alias];
        if (assert && !exists) {
            this.log.warn(`No sound matching alias '${alias}'.`);
        }
        return exists;
    }
    sound(alias) {
        this.exists(alias, true);
        return this._sounds[alias];
    }
    play(alias, options) {
        Runtime_1.default.instance.performance.log('JiboSoundPlayEvent', alias);
        this.log.debug("Starting to Playback Sound with alias:" + alias);
        let sound = this.sound(alias);
        return (sound ? sound.play(options) : null);
    }
    stop(alias) {
        let sound = this.sound(alias);
        return (sound ? sound.stop() : null);
    }
    pause(alias) {
        let sound = this.sound(alias);
        return (sound ? sound.pause() : null);
    }
    resume(alias) {
        let sound = this.sound(alias);
        return (sound ? sound.resume() : null);
    }
    destroy() {
        this.removeAll();
        this._sounds = null;
        this._context = null;
    }
}
Runtime_1.default.registerPlugin(SoundPlugin, 'sound', {
    api: true,
    electron: true
});
exports.default = SoundPlugin;

},{"../Runtime":1,"./Sound":192,"./SoundContext":193,"./SoundInstance":194,"./SoundUtils":196,"./tasks/SoundTask":199,"jibo-log":undefined}],196:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Sound_1 = require("./Sound");
const Runtime_1 = require("../Runtime");
const uuid = require("uuid");
class SoundUtils {
    static sineTone(hertz, seconds) {
        const soundContext = Runtime_1.default.instance.sound.context;
        const sound = new Sound_1.default(soundContext, {
            block: true
        });
        hertz = hertz || 200;
        seconds = seconds || 1;
        const nChannels = 1;
        const sampleRate = 48000;
        const amplitude = 2;
        const buffer = soundContext.context.createBuffer(nChannels, seconds * sampleRate, sampleRate);
        const fArray = buffer.getChannelData(0);
        for (let i = 0; i < fArray.length; i++) {
            let time = i / buffer.sampleRate;
            let angle = hertz * time * Math.PI;
            fArray[i] = Math.sin(angle) * amplitude;
        }
        sound.buffer = buffer;
        sound.isLoaded = true;
        return sound;
    }
    static playOnce(src, callback) {
        const alias = uuid.v4();
        Runtime_1.default.instance.loader.load({
            type: 'sound',
            id: alias,
            src: src,
            complete: (err, sound) => {
                if (err) {
                    if (callback) {
                        callback(err);
                    }
                    return;
                }
                sound.play((sound) => {
                    Runtime_1.default.instance.sound.remove(alias);
                    if (callback) {
                        callback(null);
                    }
                });
            }
        });
        return alias;
    }
    static addClipSounds(clip, labelPrefix = 'playAudio', separator = '-') {
        const labels = clip.labels;
        for (let i = 0; i < labels.length; ++i) {
            const label = labels[i].label;
            if (label.startsWith(labelPrefix + separator)) {
                const alias = label.split(separator)[1];
                clip.addAction(() => {
                    Runtime_1.default.instance.sound.play(alias);
                }, label);
            }
        }
        return clip;
    }
}
exports.default = SoundUtils;

},{"../Runtime":1,"./Sound":192,"uuid":undefined}],197:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Sound_1 = require("./Sound");
exports.Sound = Sound_1.default;
const SoundContext_1 = require("./SoundContext");
exports.SoundContext = SoundContext_1.default;
const ChainBuilder_1 = require("./ChainBuilder");
exports.ChainBuilder = ChainBuilder_1.default;
const SoundPlugin_1 = require("./SoundPlugin");
exports.SoundPlugin = SoundPlugin_1.default;
const SoundInstance_1 = require("./SoundInstance");
exports.SoundInstance = SoundInstance_1.default;
const SoundUtils_1 = require("./SoundUtils");
exports.SoundUtils = SoundUtils_1.default;
const tasks_1 = require("./tasks");
exports.tasks = tasks_1.default;

},{"./ChainBuilder":191,"./Sound":192,"./SoundContext":193,"./SoundInstance":194,"./SoundPlugin":195,"./SoundUtils":196,"./tasks":200}],198:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log_1 = require("../log");
exports.default = log_1.default.createChild('Sound');

},{"../log":75}],199:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../../Runtime");
const jibo_loader_1 = require("jibo-loader");
const jibo_plugins_1 = require("jibo-plugins");
const path = require("path");
const log_1 = require("../log");
const log = log_1.default.createChild('SoundTask');
class SoundTask extends jibo_loader_1.Task {
    static test(asset) {
        return !!asset.src && /\.(mp3|m4a|wav|ogg|oga|aif)$/i.test(asset.src);
    }
    constructor(manager, asset) {
        super(manager, asset, asset.src);
        this.src = this.prepare(asset.src);
        this.block = !!asset.block;
        this.volume = asset.volume || 1;
        this.panning = asset.panning || 0;
        this.loop = !!asset.loop;
        this.autoPlay = !!asset.autoPlay;
        this.useXHR = asset.remote === true || jibo_plugins_1.PathUtils.isURL(this.src);
    }
    start(callback) {
        const alias = this.id || path.parse(this.src).name;
        const soundPlugin = Runtime_1.default.instance.sound;
        if (soundPlugin.exists(alias)) {
            const sound = soundPlugin.sound(alias);
            if (sound.src === this.src) {
                return callback(null, sound);
            }
            else {
                log.info(`Overwriting existing sound (alias: ${alias})`);
                soundPlugin.remove(alias);
            }
        }
        const sound = soundPlugin.add(alias, {
            src: this.src,
            preload: true,
            block: this.block,
            loop: this.loop,
            volume: this.volume,
            panning: this.panning,
            autoPlay: this.autoPlay,
            useXHR: this.useXHR,
            loaded: callback
        });
        sound.__baseDestroy = sound.destroy;
        sound.destroy = function () {
            if (this.__destroyed) {
                return;
            }
            this.__destroyed = true;
            soundPlugin.remove(alias);
            this.__baseDestroy(true);
        };
    }
}
exports.default = SoundTask;

},{"../../Runtime":1,"../log":198,"jibo-loader":undefined,"jibo-plugins":undefined,"path":undefined}],200:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const SoundTask_1 = require("./SoundTask");
exports.default = {
    SoundTask: SoundTask_1.default
};

},{"./SoundTask":199}],201:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class DelayedCall {
    constructor(parent, callback, delay, options) {
        options = Object.assign({
            repeat: false,
            autoDestroy: true,
            useFrames: false
        }, options || {});
        this.parent = parent;
        this._callback = callback;
        this._delay = delay;
        this._timer = delay;
        this._repeat = !!options.repeat;
        this._autoDestroy = !!options.autoDestroy;
        this._useFrames = !!options.useFrames;
        this._paused = false;
        this._update = this.update.bind(this);
        this.enabled = true;
    }
    update(elapsed) {
        if (!this._callback) {
            this.destroy();
            return;
        }
        this._timer -= this._useFrames ? 1 : elapsed;
        if (this._timer <= 0) {
            this._callback(this);
            if (this._repeat) {
                this._timer += this._delay;
            }
            else if (this._autoDestroy) {
                this.destroy();
            }
            else {
                this.enabled = false;
            }
        }
    }
    restart() {
        if (!this._callback) {
            return;
        }
        if (!this.enabled) {
            this.enabled = true;
        }
        this._timer = this._delay;
        this._paused = false;
    }
    stop() {
        this.enabled = false;
        this._paused = false;
    }
    set enabled(value) {
        this._enabled = value;
        this.parent.removeListener('update', this._update);
        if (value) {
            this.parent.on('update', this._update);
        }
    }
    get enabled() {
        return this._enabled;
    }
    get paused() {
        return this._paused;
    }
    set paused(value) {
        if (!this._callback) {
            return;
        }
        if (this._paused && !value) {
            this._paused = false;
            if (!this.enabled) {
                this.enabled = true;
            }
        }
        else if (value) {
            if (this.enabled) {
                this._paused = true;
                this.enabled = false;
            }
        }
    }
    destroy() {
        this.stop();
        this._callback = null;
    }
}
exports.default = DelayedCall;

},{}],202:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const DelayedCall_1 = require("./DelayedCall");
const EventEmitter = require("jibo-eventemitter3");
class Timer extends EventEmitter {
    constructor() {
        super();
        this.update = this.update.bind(this);
        this._paused = true;
        this._updateCount = 0;
    }
    start() {
        if (this._paused) {
            this.emit('pause', false);
            this.emit('resumed');
            this._paused = false;
            this._lastUpdate = performance.now();
            this.update();
        }
    }
    stop() {
        if (!this._paused) {
            this.emit('pause', true);
            this.emit('paused');
            this._paused = true;
            if (this._frameRequest) {
                cancelAnimationFrame(this._frameRequest);
                this._frameRequest = null;
            }
        }
    }
    update() {
        if (this._paused) {
            return;
        }
        const now = performance.now();
        const elapsed = now - this._lastUpdate;
        this._updateCount++;
        this._lastUpdate = now;
        this._frameRequest = requestAnimationFrame(this.update);
        this.emit('update', elapsed);
    }
    get paused() {
        return this._paused;
    }
    setTimeout(callback, delay, useFrames = false, autoDestroy = true) {
        return new DelayedCall_1.default(this, callback, delay, {
            repeat: false,
            autoDestroy: autoDestroy,
            useFrames: useFrames
        });
    }
    clearTimeout(call) {
        call.destroy();
    }
    setInterval(callback, delay, useFrames = false) {
        return new DelayedCall_1.default(this, callback, delay, {
            repeat: true,
            autoDestroy: false,
            useFrames: useFrames
        });
    }
    nextTick(callback, autoDestroy = true) {
        return new DelayedCall_1.default(this, callback, 1, {
            repeat: false,
            autoDestroy: autoDestroy,
            useFrames: true
        });
    }
    clearInterval(call) {
        call.destroy();
    }
    destroy() {
        this.removeAllListeners();
        this.stop();
    }
}
exports.default = Timer;

},{"./DelayedCall":201,"jibo-eventemitter3":undefined}],203:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Runtime_1 = require("../Runtime");
function run(parentLog, forceWithoutWifi = false) {
    const log = parentLog.createChild('Wipe');
    return new Promise((resolve, reject) => {
        Runtime_1.default.instance.systemManager.getMode((err, curMode) => {
            if (err) {
                log.error("Wipe - getMode error: ", err);
                reject(err);
            }
            else if (curMode === 'normal') {
                log.info("Wipe- current mode is " + curMode + ". Setting to oobe.");
                Runtime_1.default.instance.systemManager.setMode('oobe', (err) => {
                    if (err) {
                        log.error("Wipe - setMode error: ", err);
                        reject(err);
                    }
                    else {
                        resolve(true);
                    }
                });
            }
            else {
                log.info("Wipe- current mode is " + curMode + " Not setting to oobe.");
                resolve(false);
            }
        });
    })
        .then((wasNormalMode) => {
        if (forceWithoutWifi && !Runtime_1.default.instance.wifi.isConnected()) {
            return;
        }
        return new Promise((resolve, reject) => {
            log.info("Wipe - suspending loop...");
            Runtime_1.default.instance.kb.loop.suspend((err) => {
                if (err) {
                    log.error("Wipe - suspend loop error:", err);
                    if (err.toString().includes('LOOP_NOT_FOUND')) {
                        log.warn('Loop not found; Continuing with wipe...');
                        resolve();
                    }
                    if (wasNormalMode) {
                        Runtime_1.default.instance.systemManager.setMode('normal', () => {
                            reject(err);
                        });
                    }
                    else {
                        reject(err);
                    }
                }
                else {
                    resolve();
                }
            });
        });
    })
        .then(() => {
        return new Promise((resolve) => {
            log.info("Wipe - system manager wipe...");
            Runtime_1.default.instance.systemManager.wipe((err) => {
                if (err) {
                    log.error("Wipe error:", err);
                }
                resolve();
            });
        });
    })
        .then(() => {
        if (forceWithoutWifi && !Runtime_1.default.instance.wifi.isConnected()) {
            return;
        }
        return new Promise((resolve) => {
            log.info("Wipe - force upload of logs...");
            Runtime_1.default.instance.systemManager.forceLogs((err) => {
                if (err) {
                    log.error("Wipe - force log upload error:", err);
                }
                resolve();
            });
        });
    })
        .then(() => {
        return new Promise((resolve) => {
            log.info("Wipe - clearing credentials...");
            Runtime_1.default.instance.systemManager.setCredentials({
                "accessKeyId": "",
                "secretAccessKey": "",
                "region": ""
            }, (err) => {
                if (err) {
                    log.error("Wipe - set credentials error: ", err);
                }
                resolve();
            });
        });
    })
        .then(() => {
        return new Promise((resolve) => {
            log.info("Wipe - clearing wi-fi networks...");
            Runtime_1.default.instance.wifi.removeAllNetworks((err) => {
                if (err) {
                    log.error("Wipe - clear wifi networks error: ", err);
                }
                resolve();
            });
        });
    })
        .catch((err) => {
        throw err;
    });
}
exports.default = {
    run
};

},{"../Runtime":1}],204:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
function configurable(value) {
    return function (target, propertyKey) {
        let descriptor = Object.getOwnPropertyDescriptor(target, propertyKey);
        descriptor.configurable = value;
        Object.defineProperty(target, propertyKey, descriptor);
    };
}
exports.configurable = configurable;
function writable(value) {
    return function (target, propertyKey) {
        let descriptor = Object.getOwnPropertyDescriptor(target, propertyKey);
        descriptor.writable = value;
        Object.defineProperty(target, propertyKey, descriptor);
    };
}
exports.writable = writable;
function enumerable(value) {
    return function (target, propertyKey) {
        let descriptor = Object.getOwnPropertyDescriptor(target, propertyKey);
        descriptor.enumerable = value;
        Object.defineProperty(target, propertyKey, descriptor);
    };
}
exports.enumerable = enumerable;
function constant(target, propertyKey) {
    let descriptor = Object.getOwnPropertyDescriptor(target, propertyKey);
    descriptor.writable = false;
    descriptor.configurable = false;
    Object.defineProperty(target, propertyKey, descriptor);
}
exports.constant = constant;
function isInitialized(target, propertyKey, descriptor) {
    let originalMethod = descriptor.value;
    descriptor.value = function () {
        let args = Array.from(arguments);
        if (!this.isInitialized) {
            let callback = args.slice(0, -1)[0];
            let err = new Error(`${this.constructor.name} class instance is not initialized`);
            callback(err);
            return undefined;
        }
        else {
            return originalMethod.apply(this, args);
        }
    };
    return descriptor;
}
exports.isInitialized = isInitialized;
function promisify(target, propertyKey, descriptor) {
    let originalMethod = descriptor.value;
    descriptor.value = function () {
        let result;
        let args = Array.from(arguments);
        let callbackArg = args[args.length - 1];
        if (typeof callbackArg === 'function') {
            result = originalMethod.apply(this, args);
        }
        else {
            result = new Promise((resolve, reject) => {
                let callback = function (err, arg) {
                    if (err) {
                        reject(err);
                    }
                    else {
                        resolve(arg);
                    }
                };
                let newArgs = args.concat(callback);
                originalMethod.apply(this, newArgs);
            });
        }
        return result;
    };
    return descriptor;
}
exports.promisify = promisify;
function promisify_n(argNum) {
    function doPromisify(target, propertyKey, descriptor) {
        let originalMethod = descriptor.value;
        descriptor.value = function () {
            let result;
            let args = Array.from(arguments);
            if (argNum < 1 || argNum > originalMethod.length) {
                throw new Error('promisify_n decorator given invalid argument number');
            }
            let callbackArg = args[argNum - 1];
            if (typeof callbackArg === 'function') {
                result = originalMethod.apply(this, args);
            }
            else {
                result = new Promise((resolve, reject) => {
                    let callback = function (err, arg) {
                        if (err) {
                            reject(err);
                        }
                        else {
                            resolve(arg);
                        }
                    };
                    let newArgs = args.slice(0, argNum - 1).concat(callback).concat(args.slice(argNum - 1));
                    originalMethod.apply(this, newArgs);
                });
            }
            return result;
        };
        return descriptor;
    }
    return doPromisify;
}
exports.promisify_n = promisify_n;

},{}],205:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.default = !!process.versions.electron;

},{}],206:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const Timer_1 = require("./Timer");
const DelayedCall_1 = require("./DelayedCall");
const perf_1 = require("./perf");
const WipeUtil_1 = require("./WipeUtil");
const jibo_plugins_1 = require("jibo-plugins");
const jibo_data_utils_1 = require("jibo-data-utils");
const log_1 = require("./log");
jibo_data_utils_1.initLog(log_1.default);
exports.default = {
    Timer: Timer_1.default,
    DelayedCall: DelayedCall_1.default,
    perf: perf_1.default,
    PathUtils: jibo_plugins_1.PathUtils,
    WipeUtil: WipeUtil_1.default,
    Location: jibo_data_utils_1.Location,
    LocationUtils: jibo_data_utils_1.LocationUtils,
    Timezone: jibo_data_utils_1.Timezone,
    DateTime: jibo_data_utils_1.DateTime,
    DateTimeUtils: jibo_data_utils_1.DateTimeUtils
};

},{"./DelayedCall":201,"./Timer":202,"./WipeUtil":203,"./log":208,"./perf":213,"jibo-data-utils":undefined,"jibo-plugins":undefined}],207:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const jibo_data_utils_1 = require("jibo-data-utils");
const Runtime_1 = require("../../Runtime");
const log_1 = require("../log");
const log = log_1.default.createChild('Location');
class HomeLocation extends jibo_data_utils_1.Location {
    static init() {
        jibo_data_utils_1.setHome(new HomeLocation());
    }
    constructor() {
        super();
        this.needsTimezone = true;
        const jibo = Runtime_1.default.instance;
        this._kbInit = jibo.kb.onInit()
            .then(() => {
            this._kb = jibo.kb.createModel('/jibo/location');
            return this._kb.loadRoot();
        })
            .then((node) => {
            this._rootNode = node;
        });
        this._kbInit.then(() => {
            jibo.kb.robot.events.robotUpdated.on(() => {
                setTimeout(() => {
                    this.readFromKB();
                }, 3000);
            });
            return this.readFromKB();
        });
    }
    fetch(callback) {
        this._kbInit.then(() => {
            return this.readFromKB();
        })
            .then(() => {
            super.fetch(callback);
        }, (err) => {
            callback(err, null);
        });
    }
    readFromKB() {
        return this._kb.load(this._rootNode.getEdges(['home', 'timezone']))
            .then((nodes) => {
            const data = nodes[0].data;
            this.city = data.city;
            this.state = data.state;
            this.stateAbbr = data.stateAbbr;
            this.country = data.country;
            this.countryCode = data.countryCode;
            this.lat = data.lat;
            this.lng = data.lng;
            if (this.state && !this.stateAbbr) {
                const fullState = jibo_data_utils_1.LocationUtils.getFullState(this.state.toLowerCase());
                if (fullState) {
                    this.stateAbbr = this.state;
                    this.state = fullState;
                }
            }
            const jibo = Runtime_1.default.instance;
            jibo.systemManager.getMode((err, mode) => {
                if (mode === 'int-developer') {
                    log.info('Read location from KB: ', data);
                }
            });
            this.timezone = new jibo_data_utils_1.Timezone(nodes[1].data);
        })
            .catch((err) => {
            log.warn('Unable to load home location from KB', err);
            this.city = 'boston';
            this.stateAbbr = 'ma';
            this.state = 'Massachusetts';
            this.country = 'usa';
            this.countryCode = 'US';
            this.lat = 42.313352;
            this.lng = -71.1273681;
            this.timezone = new jibo_data_utils_1.Timezone({
                offsetUTC: -18000000,
                name: "Eastern Standard Time",
                id: "America/New_York",
                __type: "Timezone"
            });
        });
    }
}
exports.default = HomeLocation;

},{"../../Runtime":1,"../log":208,"jibo-data-utils":undefined}],208:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const log_1 = require("../log");
exports.default = log_1.default.createChild('Util');

},{"../log":75}],209:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const SerialTimer_1 = require("./SerialTimer");
const assert = require('assert');
let singleton = null;
class GlobalPerfTimer {
    static init() {
        assert(singleton === null, 'GlobalPerfTimer.init() should only be called once');
        return GlobalPerfTimer.reset();
    }
    static reset() {
        singleton = new SerialTimer_1.default('jibo');
        return singleton;
    }
    static get() {
        return singleton;
    }
}
exports.default = GlobalPerfTimer;

},{"./SerialTimer":212,"assert":undefined}],210:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const PerformanceTimer_1 = require("./PerformanceTimer");
class ParallelTimer extends PerformanceTimer_1.default {
    constructor(name, parent) {
        super(name, PerformanceTimer_1.default.TimerTypes.PARALLEL, parent);
    }
}
exports.default = ParallelTimer;

},{"./PerformanceTimer":211}],211:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const assert = require('assert');
const TimerTypes = {
    SERIAL: "SERIAL",
    PARALLEL: "PARALLEL"
};
class PerformanceTimer {
    constructor(name, type, parent) {
        this.name = name;
        this.type = type;
        this.parent = parent;
        this.start = this.now();
        this.children = [];
        if (this.parent) {
            this.parent.children.push(this);
        }
    }
    static get TimerTypes() {
        return TimerTypes;
    }
    stop() {
        assert(!this.end, "PerformanceTimer.stop() was called twice.");
        this.end = this.now();
    }
    getTimings() {
        assert(this !== null, "PerformanceTimer.printTimings() called without there being any timing data");
        return _getTimings(this, "");
    }
    now() {
        return typeof performance !== 'undefined' ?
            performance.now() : Date.now();
    }
}
function _getTimings(parentTimer, indentLevel) {
    let timerTypeSymbol = '-';
    if (!parentTimer.parent) {
        timerTypeSymbol = " ";
    }
    else if (parentTimer.parent.type === TimerTypes.PARALLEL) {
        timerTypeSymbol = "~";
    }
    let output = "";
    output += `${indentLevel}${timerTypeSymbol} "${parentTimer.name}" ${(parentTimer.end - parentTimer.start).toFixed(1)}ms\n`;
    if (parentTimer.type === TimerTypes.PARALLEL) {
        parentTimer.children.sort((a, b) => {
            return (a.end - a.start) < (b.end - b.start);
        });
    }
    parentTimer.children.forEach((childTimer) => {
        output += _getTimings(childTimer, indentLevel + "\t");
    });
    return output;
}
exports.default = PerformanceTimer;

},{"assert":undefined}],212:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const PerformanceTimer_1 = require("./PerformanceTimer");
class SerialTimer extends PerformanceTimer_1.default {
    constructor(name, parent) {
        super(name, PerformanceTimer_1.default.TimerTypes.SERIAL, parent);
    }
}
exports.default = SerialTimer;

},{"./PerformanceTimer":211}],213:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const GlobalPerfTimer_1 = require("./GlobalPerfTimer");
const PerformanceTimer_1 = require("./PerformanceTimer");
const ParallelTimer_1 = require("./ParallelTimer");
const SerialTimer_1 = require("./SerialTimer");
exports.default = {
    GlobalPerfTimer: GlobalPerfTimer_1.default,
    PerformanceTimer: PerformanceTimer_1.default,
    ParallelTimer: ParallelTimer_1.default,
    SerialTimer: SerialTimer_1.default
};

},{"./GlobalPerfTimer":209,"./ParallelTimer":210,"./PerformanceTimer":211,"./SerialTimer":212}],214:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const electron_1 = require("./utils/electron");
const events_1 = require("./services/events");
const GlobalPerfTimer_1 = require("./utils/perf/GlobalPerfTimer");
const plugins_1 = require("./plugins");
const Runtime_1 = require("./Runtime");
const SerialTimer_1 = require("./utils/perf/SerialTimer");
const services_1 = require("./services");
const utils_1 = require("./utils");
const deprecation_1 = require("./deprecation");
const root = global;
GlobalPerfTimer_1.default.init();
const timer = new SerialTimer_1.default('jibo required', GlobalPerfTimer_1.default.get());
if (!root.jibo) {
    const classes = {
        events: events_1.default,
        plugins: plugins_1.default,
        Runtime: Runtime_1.default,
        services: services_1.default,
        utils: utils_1.default,
    };
    if (electron_1.default) {
        const rendering = require('./rendering');
        const bt = require('./bt');
        const flow = require('./flow');
        const sound = require('./sound');
        Object.assign(classes, {
            bt,
            flow,
            rendering,
            sound,
        });
    }
    deprecation_1.default(classes);
    root.jibo = new Runtime_1.default(classes);
}
timer.stop();
module.exports = root.jibo;

},{"./Runtime":1,"./bt":48,"./deprecation":65,"./flow":73,"./plugins":98,"./rendering":159,"./services":183,"./services/events":181,"./sound":197,"./utils":206,"./utils/electron":205,"./utils/perf/GlobalPerfTimer":209,"./utils/perf/SerialTimer":212}]},{},[214])(214)
});

//# sourceMappingURL=jibo.js.map