(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.jiboKeyframes = 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 });
/**
 * All meta data related to a jibo .keys file. This is passed to the keyframes.runtime functions
 * to make it aware of specific layers and their properties/info.
 */
const semver = require("semver");
const BodyLayer_1 = require("./layers/BodyLayer");
const EyeLayer_1 = require("./layers/EyeLayer");
const OverlayLayer_1 = require("./layers/OverlayLayer");
const EyeTextureLayer_1 = require("./layers/EyeTextureLayer");
const OverlayTextureLayer_1 = require("./layers/OverlayTextureLayer");
const BackgroundTextureLayer_1 = require("./layers/BackgroundTextureLayer");
const LEDLayer_1 = require("./layers/LEDLayer");
const PixiLayer_1 = require("./layers/PixiLayer");
const EventLayer_1 = require("./layers/EventLayer");
const AudioLayer_1 = require("./layers/AudioLayer");
const ReferenceLayer_1 = require("./layers/ReferenceLayer");
const IDUtils_1 = require("./utils/IDUtils");
const Conversion_1 = require("./utils/Conversion");
const Colors_1 = require("./utils/Colors");
class JiboKeyframeInfo {
    /**
     * Implement this to do any backward compatibility related touchups to old files
     */
    static onLoad(keyframes) {
        // TODO: Figure out why the version isn't always in files
        keyframes.version = keyframes.version || "0.3.0";
        // Layers didn't have an id at 0.2.0, add some for old files
        if (keyframes.version === "0.2.0") {
            keyframes.layers.forEach((layer) => {
                layer.id = IDUtils_1.default.create();
            });
        }
        // 0.4.0 changed the coordinate system of the eye/overlay from
        // meters to pixel coordinates
        if (semver.lt(keyframes.version, "0.4.0")) {
            // Find each eye and overlay layer and then convert each property
            // that represents a translation from meters to pixel coordinates
            keyframes.layers.forEach((layer) => {
                if (layer.type === "Eye" || layer.type === "Overlay") {
                    layer.keyframes.forEach((key) => {
                        for (let prop in key.value) {
                            // Everything but Scale and Rotate are x/y pairs
                            // representing 2D translations
                            if (prop !== "Scale" &&
                                prop !== "Rotate") {
                                key.value[prop].x = Conversion_1.default.toPixelsX(key.value[prop].x);
                                key.value[prop].y = Conversion_1.default.toPixelsY(key.value[prop].y);
                            }
                        }
                    });
                }
            });
        }
        if (semver.lte(keyframes.version, '0.4.0')) {
            keyframes.layers.forEach((layer) => {
                layer.keyframes.forEach((key) => {
                    for (let prop in key.value) {
                        if (prop === "Tween" && key.value.Tween.value === 'body') {
                            key.value.Tween = {
                                display: 'cubic in out',
                                label: 'Cubic Ease In Out',
                                value: 'cubicInOut'
                            };
                        }
                    }
                });
            });
        }
        // 0.5.0 changed colors to use rgb instead of hsv for blending and internal representation
        if (semver.lt(keyframes.version, "0.5.0")) {
            keyframes.layers.forEach((layer) => {
                if (layer.type === "Background Texture" || layer.type === "Eye Texture" ||
                    layer.type === "Overlay Texture" || layer.type === "LED") {
                    // Find each Color property and convert it from hsv space to rgb
                    layer.keyframes.forEach((key) => {
                        key.value.Color = Colors_1.default.hsvToRgb(key.value.Color.h, key.value.Color.s, key.value.Color.v);
                    });
                }
            });
        }
        // 0.6.0 eye and overlay coordinates were off vertically causing squishing. This was
        // because the conversion between vertical meters and pixels was off. We fixed the conversion
        // and now we have to touch up coordinates from old files so that animations created that
        // compensated for the squish would be broken by this fix
        if (semver.lt(keyframes.version, "0.6.0")) {
            keyframes.layers.forEach((layer) => {
                if (layer.type === "Overlay" || layer.type === "Eye") {
                    // Find each Color property and convert it from hsv space to rgb
                    layer.keyframes.forEach((key) => {
                        for (let field in key.value) {
                            if (field !== 'Scale' &&
                                typeof key.value[field].y !== 'undefined') {
                                key.value[field].y = key.value[field].y * 0.06922346 / 0.073142126;
                            }
                        }
                    });
                }
            });
        }
        if (semver.lt(keyframes.version, "0.7.0")) {
            keyframes.layers.forEach((layer) => {
                if (layer.type === "Overlay" || layer.type === "Eye") {
                    // Find each Color property and convert it from hsv space to rgb
                    layer.keyframes.forEach((key) => {
                        key.value.Alpha = 1.0;
                        key.value.Visible = true;
                    });
                }
                else if (layer.type === "Pixi") {
                    layer.keyframes.forEach((key) => {
                        console.log("Upgrade to attach and effect");
                        key.value["Attach To Eye"] = false;
                        key.value["Apply Eye Lighting"] = false;
                    });
                }
            });
        }
        // Deprecate the Apply Eye Lighting and add a frame offset
        if (semver.lt(keyframes.version, "0.9.0")) {
            keyframes.layers.forEach((layer) => {
                if (layer.type === "Pixi") {
                    layer.keyframes.forEach((key) => {
                        console.log("Add frame offset, deprecated lighting");
                        key.value["Frame Offset"] = 0;
                        delete key.value["Apply Eye Lighting"];
                    });
                }
            });
        }
        // 0.9 Added reference layers (No upgrade needed as it only adds a new layer type)
        // 0.10.0 Deprecate the Apply Eye Lighting and add a frame offset
        if (semver.lt(keyframes.version, "0.10.0")) {
            keyframes.layers.forEach((layer) => {
                if (layer.type === "Glow") {
                    layer.keyframes.forEach((key) => {
                        console.log("Deprecated halo speed on Glow");
                        delete key.value.HaloSpeed;
                    });
                }
            });
        }
        // 0.11.0: Reference layer upgrade
        if (semver.lt(keyframes.version, "0.11.0")) {
            keyframes.layers.forEach((layer) => {
                // Upgrade reference layers to have "hide before" and "hide after" properties set to false
                if (layer.type === "Reference") {
                    layer.keyframes.forEach((key) => {
                        console.log("Add Hide-Before Hide-After to reference layer");
                        key.value["Hide Referenced Layers Before Use"] = true;
                        key.value["Hide Referenced Layers After Use"] = true;
                    });
                }
                // Upgrade other layers to have their HideLayer properties set to false
                if (layer.type === 'Overlay Texture'
                    || layer.type === 'Overlay'
                    || layer.type === 'Eye Texture'
                    || layer.type === 'Eye') {
                    layer.keyframes.forEach((key) => {
                        key.value["HideLayer"] = false;
                    });
                }
            });
        }
        // 0.12.0: Remove 'Hide Layers Before Use' field in Reference layer.
        if (semver.lt(keyframes.version, "0.12.0")) {
            keyframes.layers.forEach((layer) => {
                // Upgrade reference layers to have "hide before" and "hide after" properties set to false
                if (layer.type === "Reference") {
                    layer.keyframes.forEach((key) => {
                        console.log("Remove Hide-Before and Hide-After from reference layer");
                        delete key.value["Hide Referenced Layers Before Use"];
                        key.value["HoldFinalPose"] = !key.value["Hide Referenced Layers After Use"];
                        delete key.value["Hide Referenced Layers After Use"];
                    });
                }
            });
        }
        // 0.13.0: Remove 'Hide Layer' field.
        if (semver.lt(keyframes.version, "0.13.0")) {
            keyframes.layers.forEach((layer) => {
                // Downgrade various layers to remove their HideLayer property
                if (layer.type === 'Overlay Texture'
                    || layer.type === 'Overlay'
                    || layer.type === 'Eye Texture'
                    || layer.type === 'Eye') {
                    layer.keyframes.forEach((key) => {
                        delete key.value["HideLayer"];
                    });
                }
            });
        }
        // 0.14.0: Add ReferenceMode field (set to "file" mode) to reference layers. Upgrade KeysFileReference to have
        // an empty anim name.
        if (semver.lt(keyframes.version, "0.14.0")) {
            keyframes.layers.forEach((layer) => {
                if (layer.type === 'Reference') {
                    layer.keyframes.forEach((key) => {
                        key.value.ReferenceMode = {
                            display: 'File Path',
                            label: 'By File path',
                            value: 'file'
                        };
                        key.value.KeysFileReference.name = "";
                    });
                }
            });
        }
        var removeGlowAndLightingLayers = true;
        // 0.15.0: Remove glow and lighting layers from the file, they are deprecated from the editor.
        if (removeGlowAndLightingLayers && semver.lt(keyframes.version, "0.15.0")) {
            let newLayers = [];
            for (let layer of keyframes.layers) {
                if (layer.type === 'Glow' || layer.type === 'Lighting') {
                    continue;
                }
                newLayers.push(layer);
            }
            keyframes.layers = newLayers;
        }
        // Make version is set to the latest
        keyframes.version = JiboKeyframeInfo.defaults.version;
    }
}
// Layer types that jibo supports. For efficient access, layerTypes indexes
// each Layer Types constructor by it's name (ie. "Body": Body)
JiboKeyframeInfo.layerTypes = {
    Body: BodyLayer_1.default,
    Eye: EyeLayer_1.default,
    "Eye Texture": EyeTextureLayer_1.default,
    Overlay: OverlayLayer_1.default,
    "Overlay Texture": OverlayTextureLayer_1.default,
    "Background Texture": BackgroundTextureLayer_1.default,
    LED: LEDLayer_1.default,
    Event: EventLayer_1.default,
    "Audio Event": AudioLayer_1.default,
    Reference: ReferenceLayer_1.default
};
JiboKeyframeInfo.layerTypes.Pixi = PixiLayer_1.default;
JiboKeyframeInfo.defaults = {
    version: "0.15.0",
    framerate: 30,
    duration: 30,
    scale: 1,
    // Layers that newly created Jibo Keyframe files have
    layers: [
        {
            name: "Eye",
            type: "Eye"
        },
        {
            name: "Body",
            type: "Body"
        },
        {
            name: "Overlay",
            type: "Overlay",
            visible: true,
            locked: false,
            keyframes: [
                {
                    "value": {
                        "Rotate": 0,
                        "Scale": {
                            "x": 1,
                            "y": 1
                        },
                        "Translate": {
                            "x": 0,
                            "y": 0
                        },
                        "Visible": false,
                        "Alpha": 1,
                        "Tween": {
                            "display": "sine in out",
                            "label": "Sine Ease In Out",
                            "value": "sineInOut"
                        },
                        "Vertex 1": {
                            "x": -EyeLayer_1.default.eyeRadiusX,
                            "y": -EyeLayer_1.default.eyeRadiusY
                        },
                        "Vertex 2": {
                            "x": 0,
                            "y": -EyeLayer_1.default.eyeRadiusY
                        },
                        "Vertex 3": {
                            "x": EyeLayer_1.default.eyeRadiusX,
                            "y": -EyeLayer_1.default.eyeRadiusY
                        },
                        "Vertex 4": {
                            "x": -EyeLayer_1.default.eyeRadiusX,
                            "y": 0
                        },
                        "Vertex 5": {
                            "x": 0,
                            "y": 0
                        },
                        "Vertex 6": {
                            "x": EyeLayer_1.default.eyeRadiusX,
                            "y": 0
                        },
                        "Vertex 7": {
                            "x": -EyeLayer_1.default.eyeRadiusX,
                            "y": EyeLayer_1.default.eyeRadiusY
                        },
                        "Vertex 8": {
                            "x": 0,
                            "y": EyeLayer_1.default.eyeRadiusY
                        },
                        "Vertex 9": {
                            "x": EyeLayer_1.default.eyeRadiusX,
                            "y": EyeLayer_1.default.eyeRadiusY
                        }
                    },
                    "time": 0
                }
            ]
        }
    ]
};
exports.default = JiboKeyframeInfo;

},{"./layers/AudioLayer":6,"./layers/BackgroundTextureLayer":7,"./layers/BodyLayer":8,"./layers/EventLayer":9,"./layers/EyeLayer":11,"./layers/EyeTextureLayer":12,"./layers/LEDLayer":13,"./layers/OverlayLayer":14,"./layers/OverlayTextureLayer":15,"./layers/PixiLayer":16,"./layers/ReferenceLayer":17,"./utils/Colors":20,"./utils/Conversion":21,"./utils/IDUtils":22,"semver":undefined}],2:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
/**
 * Class responsible for
 *   - saving and loading files
 *   - manipulating the animation and notifying views of changes
 *   - computing the values of animation at any given point in time
 */
const fs = require("fs");
const lodash_min_1 = require("lodash/lodash.min");
const Tweening_1 = require("./utils/Tweening");
const IDUtils_1 = require("./utils/IDUtils");
const Search_1 = require("./utils/Search");
const BlendOperations_1 = require("./utils/BlendOperations");
class Runtime {
    /**
     * Create a new keyframes object.
     *
     * @param keyframeInfo {Object} Meta data that includes supported layer types,
     *                              default values, and etc
     * @returns {Object} The newly created keyframes object with default layers created
     *
     */
    static create(keyframeInfo) {
        let keyframes = {
            version: keyframeInfo.defaults.version,
            framerate: keyframeInfo.defaults.framerate,
            duration: keyframeInfo.defaults.duration,
            scale: keyframeInfo.defaults.scale,
            layers: []
        };
        keyframeInfo.defaults.layers.forEach((defaultLayer) => {
            keyframes.layers.push({
                id: IDUtils_1.default.create(),
                name: defaultLayer.name,
                type: defaultLayer.type,
                visible: true,
                locked: false,
                keyframes: lodash_min_1.cloneDeep(defaultLayer.keyframes || [])
            });
        });
        return keyframes;
    }
    /**
     * Load an animation file into this instance
     *
     * @param uri {String} Filepath to load the keyframes file from
     * @param keyframeInfo {Object} Meta data that includes supported layer types,
     *                              default values, and etc
     * @returns {Object} Keyframes file content
     *
     * TODO: Write validation code at some point to catch issues like a file that merged incorrectly,
     * was corrupted, or is just the wrong file format/type. Ensure invariants such as:
     *   - That keys are time ordered
     *   - That key values are valid
     *   - That all required fields exist and no extra ones do
     */
    static load(uri, keyframeInfo) {
        let keyframes = JSON.parse(fs.readFileSync(uri, 'utf8'));
        if (keyframeInfo.onLoad) {
            keyframeInfo.onLoad(keyframes);
        }
        return keyframes;
    }
    /**
     * Save the keyframes to disk
     *
     * @param uri {String} Filepath to save to
     * @param keyframes {Object} Keyframe object to serialize to disk
     */
    static save(uri, keyframes) {
        // Save the current animation state to disk with four spaces for indentation
        fs.writeFileSync(uri, JSON.stringify(keyframes, null, '    '), 'utf8');
    }
    static _isEventLayer(layer, keyframeInfo) {
        if (layer) {
            let layerClass = keyframeInfo.layerTypes[layer.type];
            return layerClass.isEvent();
        }
        return false;
    }
    /**
     * Get the dof values generated from all the DOF layers at a point in time
     * @param keyframes {Object} Keyframes data we'll be evaluating the layers of
     * @param keyframeInfo {Object} Meta data that includes supported layer types,
     *                              default values, and etc
     * @param timeInSeconds {number} The time to compute the final dof values at
     * @param overrides {Object} If provided each field in this object includes a set of properties
     *                           to override the usually calculated interpolated keyframed properties.
     *                           This is useful in tools for interactively changing
     *                           the properties of a layer at a point in time without
     *                           committing a new keyframe as a user tries out different jibo poses
     * @return {Object} An object who's fields are each dof and it's value after all
     *                  interpolation and layer blending
     */
    static evaluateAllDOFLayers(keyframes, keyframeInfo, timeInSeconds, overrides) {
        let accumulatedProps = Runtime.evaluateAllLayersFiltered(keyframes, keyframeInfo, timeInSeconds, (layer) => {
            return !Runtime._isEventLayer(layer, keyframeInfo); // only care about non-event layers (DOF)
        }, overrides);
        // Now that all props have been accumulated, pass them to
        // the layer types generateDofs() function to get our final dof values
        let dofs = {};
        for (let layerType in accumulatedProps) {
            let layerClass = keyframeInfo.layerTypes[layerType];
            let generatedDofs = layerClass.generateDofs(accumulatedProps[layerType]);
            // Copy These
            // TODO: Eventually multiple types of layers will be generating dof values
            // so blending operations will need to occur here as well.
            for (let dofName in generatedDofs) {
                dofs[dofName] = generatedDofs[dofName];
            }
        }
        return dofs;
    }
    /**
     * Detect whether the layer was originally from a referenced layer.
     * (Every referenced layer's ID is prefixed with the parent (i.e. referencing)
     * layer's ID and delimited with "-" as part of the compositing operation).
     * @param {*} layer
     * @returns {boolean}
     */
    static isReferencedLayer(layer) {
        return layer.id.indexOf('-') > 0;
    }
    /**
     * Detect whether there were any layers of the given type in the referenced layers.
     * @param {Keyframes} keyframes
     * @params {string} type the string name of the layer type we're looking for.
     * @returns {boolean}
     */
    static hasReferencedLayersOfType(keyframes, type) {
        for (let i = 0; i < keyframes.layers.length; i++) {
            let layer = keyframes.layers[i];
            if (this.isReferencedLayer(layer) && layer.type === type) {
                return true;
            }
        }
        return false;
    }
    /**
     * Evaluate and Blend the layers within keyframes (filtering some out).
     * Handles Blink Layer Mode:
     * Any eye layers found in referenced layers put us in so-called "blink layer" mode, which operates as follows:
     * The eye layers at top level are used to blend all the referenced eye and [any] referenced overlay layers.
     * If any referenced layers contain overlays, the top level overlay layers are ignored.
     * All other layers are blended normally.
     * @param {Keyframes} keyframes
     * @param keyframeInfo
     * @param {number} timeInSeconds
     * @param {Callback} includeFilter
     * @param overrides
     * @returns {*}
     */
    static evaluateAllLayersFiltered(keyframes, keyframeInfo, timeInSeconds, includeFilter, overrides) {
        // If we are not in Blink Layer mode, perform the standard layer evaluation for all layers.
        if (!this.hasReferencedLayersOfType(keyframes, 'Eye')) {
            return this.evaluateLayersFiltered(keyframes, keyframeInfo, timeInSeconds, includeFilter, overrides);
        }
        // "Blink layer mode" combines the Eye and Overlay in the Top and Reference layers in a particular way.
        const hasNoReferencedOverlays = !this.hasReferencedLayersOfType(keyframes, 'Overlay');
        const topFilter = (layer) => {
            return includeFilter(layer) && !this.isReferencedLayer(layer) && layer.type === 'Eye';
        };
        const refFilter = (layer) => {
            return includeFilter(layer) && this.isReferencedLayer(layer) && (layer.type === 'Eye' || layer.type === 'Overlay');
        };
        const otherFilter = (layer) => {
            return includeFilter(layer) && layer.type !== 'Eye' && (layer.type !== 'Overlay' || hasNoReferencedOverlays);
        };
        // Gather up the Eye and Overlay properties from Ref layers.
        const ref = this.evaluateLayersFiltered(keyframes, keyframeInfo, timeInSeconds, refFilter, overrides);
        // If no layers in the reference are currently active, we are not in blink mode.
        if (Object.keys(ref).length === 0) {
            return this.evaluateLayersFiltered(keyframes, keyframeInfo, timeInSeconds, includeFilter, overrides);
        }
        // Perform the standard evaluation of all the non-Eye/Overlay layers.
        const accumulatedProps = this.evaluateLayersFiltered(keyframes, keyframeInfo, timeInSeconds, otherFilter, overrides);
        // Gather up the Eye properties from the top layer.
        const top = this.evaluateLayersFiltered(keyframes, keyframeInfo, timeInSeconds, topFilter, overrides);
        const eyeLayerInfo = keyframeInfo.layerTypes['Eye'].getInfo();
        // Then form the final Eye and Overlay props by combining the referenced layers with the top Eye layer.
        for (let refLayerType of ['Eye', 'Overlay']) {
            if (ref[refLayerType]) {
                // Initialize this layer's properties with the referenced layer values.
                accumulatedProps[refLayerType] = ref[refLayerType];
                // However, if we have a top level Eye layer, we instead make this layer's properties by
                // blending each referenced layer property with the top level Eye layer's properties.
                if (top['Eye']) {
                    for (let prop in eyeLayerInfo.properties) {
                        const propInfo = eyeLayerInfo.properties[prop];
                        const blendOp = BlendOperations_1.default.normal(propInfo.blendOperation, propInfo.type);
                        accumulatedProps[refLayerType][prop] = blendOp(top['Eye'][prop], ref[refLayerType][prop], propInfo.defaultValue);
                    }
                }
            }
        }
        return accumulatedProps;
    }
    // Evaluate all layers by tweening within each layer and then blending the tweened values together.
    static evaluateLayersFiltered(keyframes, keyframeInfo, timeInSeconds, includeFilter, overrides) {
        // This will hold each layers blended props as they accumulate
        const accumulatedProps = {};
        // Blend layers from bottom to top.
        for (let i = keyframes.layers.length - 1; i >= 0; i--) {
            const layer = keyframes.layers[i];
            // Locked, invisible, or filtered layers don't have any affect on the final props/dofs
            if (!includeFilter(layer) || !layer.visible) {
                continue;
            }
            const override = overrides === undefined ? undefined : overrides[layer.id], props = Runtime.evaluateLayer(layer, keyframes, keyframeInfo, timeInSeconds, override);
            // Ignore the entire layer if is currently marked hidden.
            if (!props) {
                continue;
            }
            const layerType = layer.type;
            // Is this the first instance of a particular layer type
            // If so initialize the accumulated props to this layer's computed values
            if (typeof accumulatedProps[layerType] === "undefined") {
                accumulatedProps[layerType] = props;
            }
            else {
                const layerProps = accumulatedProps[layerType], layerInfo = keyframeInfo.layerTypes[layerType].getInfo();
                // Blend each property based on it's type/blendOperation
                for (let propName in props) {
                    const propInfo = layerInfo.properties[propName];
                    if (!('blendOperation' in propInfo)) {
                        console.log(`blendoperation not found in ${Object.keys(propInfo)} for layerType ${layerType}`);
                        continue;
                    }
                    layerProps[propName] = BlendOperations_1.default.normal(propInfo.blendOperation, propInfo.type)(layerProps[propName], props[propName], propInfo.defaultValue);
                }
            }
        }
        return accumulatedProps;
    }
    /*
    *   Used by the editor's animation model.
    *   Turn our absoluteProps into ones relative to all the layers of our type that don't include the excluded one.
    * */
    static computeRelativePropValues(excludedLayer, keyframes, keyframeInfo, timeInSeconds, absoluteProps, overrides) {
        const props = Runtime.evaluateAllLayersFiltered(keyframes, keyframeInfo, timeInSeconds, (layer) => layer.id !== excludedLayer.id, overrides);
        // Return absolute props as is if there were no other layers of it's type
        if (typeof props[excludedLayer.type] === "undefined") {
            return absoluteProps;
        }
        const layerInfo = keyframeInfo.layerTypes[excludedLayer.type].getInfo(), relativeProps = {};
        for (let propName in absoluteProps) {
            const propInfo = layerInfo.properties[propName];
            relativeProps[propName] = BlendOperations_1.default.inverse(propInfo.blendOperation, propInfo.type)(props[excludedLayer.type][propName], absoluteProps[propName], propInfo.defaultValue);
        }
        return relativeProps;
    }
    /**
     * Get the property values generated from a single layer at a point in time
     *
     * @param layer {Object} The layer that we need to evaluate
     * @param keyframes {Object} Keyframes data that this layer is a part of
     * @param keyframeInfo {Object} Meta data that includes supported layer types,
     *                              default values, and etc
     * @param timeInSeconds {number} The time to compute the properties values at
     * @param override {Object}  If provided this object includes a set of properties
     *                           to override the usually calculated keyframed properties.
     *                           This is useful in tools for interactively changing
     *                           the properties of a layer at a point in time without
     *                           committing a new keyframe as a user tries out different jibo poses
     * @return {Object} An object who's fields are each dof and it's value after all
     *                  interpolation and layer blending. Alternatively, return undefined
     *                  if there is no valid layer at the given time.
     */
    static evaluateLayer(layer, keyframes, keyframeInfo, timeInSeconds, override) {
        if (Runtime._isEventLayer(layer, keyframeInfo)) {
            // do not interpolate for event types
            return Runtime._evaluateEventLayer(layer, keyframes, keyframeInfo, timeInSeconds);
        }
        const props = {};
        if (override) {
            for (let propName in override) {
                props[propName] = override[propName];
            }
            return props;
        }
        const layerTypeInfo = keyframeInfo.layerTypes[layer.type].getInfo();
        const defaults = {};
        for (let propName in layerTypeInfo.properties) {
            defaults[propName] = lodash_min_1.cloneDeep(layerTypeInfo.properties[propName].defaultValue);
        }
        // If there are no keyframes, return the defaults
        if (layer.keyframes.length === 0) {
            if (layer.type === 'Overlay') {
                // Except in the case of Overlay -- if there are no keyframes in the
                // overlay, pretend there is no overlay layer.
                return;
            }
            return defaults;
        }
        // There are keyframes, calculate the properties at the supplied time
        // Calculate the keyframe index this time is equivalent to.
        // NOTE: We don't floor it, we just want to have a number in frame counts
        // instead of in seconds so that we can compare times and interpolate between
        // times
        if (keyframes.scale === undefined) {
            keyframes.scale = keyframeInfo.defaults.scale;
        }
        // Floating point division in Javascript might yield non-integer values
        // that are very close (millionths) to frame numbers, but not quite
        let currentTime = Math.round(timeInSeconds * keyframes.framerate * 1000000) / 1000000;
        // Ignore layers that are not valid before the current time.
        if (layer.validFrom !== undefined && currentTime < layer.validFrom) {
            return;
        }
        // Ignore layers that are not valid after the current time.
        if (layer.validUpto !== undefined && currentTime >= layer.validUpto) {
            return;
        }
        // Hold layers at a specific timepoint if specified.
        if (layer.holdAfter !== undefined && currentTime >= layer.holdAfter) {
            currentTime = layer.holdAfter;
        }
        // Return defaults if we're before the beginning.
        if (currentTime < layer.keyframes[0].time) {
            if (layer.type === 'Overlay') {
                // Except in the case of Overlay -- if there are no keyframes before the
                // overlay, pretend there is no overlay layer.
                return;
            }
            return defaults;
        }
        // Is the current time past the time of the last keyframe? If so grab that
        // keyframe's value.
        if (currentTime >= layer.keyframes[layer.keyframes.length - 1].time) {
            return lodash_min_1.cloneDeep(layer.keyframes[layer.keyframes.length - 1].value);
        }
        // The current time is between keyframes.
        // Scan from the last to first keyframe, stop on the first keyframe
        // further back or equal in time to us.
        let { start, end } = Search_1.default.keyframeSearch(layer.keyframes, currentTime);
        start = layer.keyframes[start];
        end = layer.keyframes[end];
        // Now that we have our two closest keyframes, interpolate between their values
        const timeStart = start.time, timeEnd = end.time, timeNormalized = (currentTime - timeStart) / (timeEnd - timeStart);
        let easingFunction = 'cubicInOut';
        if (start.value.Tween) {
            easingFunction = start.value.Tween.value;
        }
        for (let propName in start.value) {
            let tweenType = layerTypeInfo.properties[propName].type;
            if (typeof tweenType !== 'string') {
                tweenType = tweenType.name;
            }
            props[propName] = Tweening_1.default[tweenType](start.value[propName], end.value[propName], timeNormalized, easingFunction);
        }
        return props;
    }
    static _evaluateEventLayer(layer, keyframes, keyframeInfo, timeInSeconds) {
        // Floating point division in Javascript might yield non-integer values
        // that are very close (millionths) to frame numbers, but not quite
        const keyframeTime = Math.round(timeInSeconds * keyframes.framerate * 1000000) / 1000000;
        // if we have a keyframe at the given keyframeTime, then return it;
        // otherwise, return the default values
        const frame = Search_1.default.keyframeSearchAbsolute(layer.keyframes, keyframeTime);
        if (frame !== undefined) {
            return lodash_min_1.cloneDeep(layer.keyframes[frame].value);
        }
        const layerTypeInfo = keyframeInfo.layerTypes[layer.type].getInfo();
        const props = {};
        for (let propName in layerTypeInfo.properties) {
            props[propName] = lodash_min_1.cloneDeep(layerTypeInfo.properties[propName].defaultValue);
        }
        return props;
    }
    /**
     * Get the event values (payloads) generated from all the event layers at a point in time
     * @param keyframes {Object} Keyframes data we'll be evaluating the layers of
     * @param keyframeInfo {Object} Meta data that includes supported layer types,
     *                              default values, and etc
     * @param timeInSeconds {number} The time to check
     *
     * @return {array} An array of all accumulated event layers and their payloads.
     */
    static evaluateAllEventLayers(keyframes, keyframeInfo, timeInSeconds) {
        const events = [];
        // Find all our event layers
        const layersLen = keyframes.layers.length;
        for (let i = 0; i < layersLen; i++) {
            const layer = keyframes.layers[i];
            // if not visible or not an event layer, move along
            if (!Runtime._isEventLayer(layer, keyframeInfo) || !layer.visible) {
                continue;
            }
            const props = Runtime.evaluateLayer(layer, keyframes, keyframeInfo, timeInSeconds);
            if (props) {
                const layerClass = keyframeInfo.layerTypes[layer.type];
                const generatedEvent = layerClass.generateEvent(props, i);
                const eventType = (typeof generatedEvent);
                if ((eventType === 'object') && (layerClass.isValid(generatedEvent))) {
                    events.push(generatedEvent);
                }
            }
        }
        return events;
    }
}
exports.default = Runtime;

},{"./utils/BlendOperations":18,"./utils/IDUtils":22,"./utils/Search":25,"./utils/Tweening":26,"fs":undefined,"lodash/lodash.min":undefined}],3:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
class BaseLayer {
    /**
     * Return type information about the layer, such as:
     *   - Properties it supports and their:
     *      - type
     *      - default values
     *      - min/max where applicable
     *      - the operation (for DOF) that the layering system uses to blend with other layers:
     *        - additive for translations, rotations, and color type properties
     *        - multiplicative for scaling
     *        - last one wins for textures
     *   - values (DOF, events, etc.) the layer generates
     * Each layer needs to implement this.
     */
    static getInfo() {
        throw "Implement static Layer.getInfo() to supply property meta data";
    }
    static isEvent() {
        throw "Implement static Layer.isEvent()";
    }
}
exports.default = BaseLayer;

},{}],4:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const BaseLayer_1 = require("./BaseLayer");
class DOFBaseLayer extends BaseLayer_1.default {
    /**
     * Given a set of properties that a layer supports return the dof values that
     * that this layer generates. The properties will have already been interpolated
     * from the keyframes of the layer and blended with other layers. Only generation
     * logic needs to be implemented.
     *
     * @param props {Object}   An object with each field having the name of each layer
     *                         property and it's interpolated/blended value
     *
     * @returns {Object}    An object with each field having the name of each generated
     *                      dof and it's value. These will then be handed to final blending
     *                      logic that blends all dofs generated from all layer types
     *                      according to their blend operation.
     */
    static generateDofs() {
        throw "Implement static Layer.generateDofs()";
    }
    static isEvent() {
        return false;
    }
}
exports.default = DOFBaseLayer;

},{"./BaseLayer":3}],5:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const BaseLayer_1 = require("./BaseLayer");
class EventBaseLayer extends BaseLayer_1.default {
    /**
     * Given a set of properties that a layer supports return the event value (payload) that
     * that this layer generates.
     *
     * @param props {Object}   An object with each field having the name of each layer
     *                         property and its event payloads if applicable
     *
     * @returns {Object}    A JSON object with the payload information for that layer
     */
    static generateEvent() {
        throw "Implement static Layer.generateEvent()";
    }
    static isEvent() {
        return true;
    }
    static isValid() {
        throw "Implement static Layer.isValid(generedatedEvent)";
    }
}
exports.default = EventBaseLayer;

},{"./BaseLayer":3}],6:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const EventBaseLayer_1 = require("../bases/EventBaseLayer");
let AudioInfo = {
    layerType: "Audio Event",
    properties: {
        AudioEvent: {
            type: "audio",
            blendOperation: 'lastOneWins',
            defaultValue: {
                file: ""
            }
        }
    }
};
/*
* Audio layer with specific payload data.
* */
class AudioLayer extends EventBaseLayer_1.default {
    static getInfo() {
        return AudioInfo;
    }
    constructor() {
        super();
    }
    static generateEvent(props) {
        let event = {
            name: "play-audio",
            payload: {
                "file": props.AudioEvent.file
            }
        };
        return event;
    }
    static isValid(generatedEvent) {
        return ((generatedEvent.name === "play-audio") &&
            (generatedEvent.payload.file.length > 0));
    }
}
exports.default = AudioLayer;

},{"../bases/EventBaseLayer":5}],7:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const DOFBaseLayer_1 = require("../bases/DOFBaseLayer");
let BackgroundTextureInfo = {
    layerType: "Background Texture",
    properties: {
        Texture: {
            type: "texture",
            defaultValue: "",
            blendOperation: "lastOneWins"
        },
        Color: {
            type: "rgb",
            defaultValue: {
                r: 255,
                g: 255,
                b: 255
            },
            blendOperation: "add"
        }
    },
    dofs: {
        screenBGTextureInfixBn_r: true,
        screenBG_redChannelBn_r: true,
        screenBG_greenChannelBn_r: true,
        screenBG_blueChannelBn_r0: true
    }
};
class BackgroundTextureLayer extends DOFBaseLayer_1.default {
    static getInfo() {
        return BackgroundTextureInfo;
    }
    constructor() {
        super();
    }
    static generateDofs(props) {
        return {
            screenBGTextureInfixBn_r: props.Texture,
            screenBG_redChannelBn_r: props.Color.r / 255.0,
            screenBG_greenChannelBn_r: props.Color.g / 255.0,
            screenBG_blueChannelBn_r: props.Color.b / 255.0
        };
    }
}
exports.default = BackgroundTextureLayer;

},{"../bases/DOFBaseLayer":4}],8:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const DOFBaseLayer_1 = require("../bases/DOFBaseLayer");
let values = [
    {
        display: 'linear',
        label: 'Linear Tween',
        value: 'linear'
    },
    {
        display: 'sine in',
        label: 'Sine Ease In',
        value: 'sineIn'
    },
    {
        display: 'sine out',
        label: 'Sine Ease Out',
        value: 'sineOut'
    },
    {
        display: 'sine in out',
        label: 'Sine Ease In Out',
        value: 'sineInOut'
    },
    {
        display: 'cubic in',
        label: 'Cubic Ease In',
        value: 'cubicIn'
    },
    {
        display: 'cubic out',
        label: 'Cubic Ease Out',
        value: 'cubicOut'
    },
    {
        display: 'cubic in out',
        label: 'Cubic Ease In Out',
        value: 'cubicInOut'
    }
];
let Tween = {
    type: {
        name: 'enum',
        values
    },
    defaultValue: values[3],
    blendOperation: 'none'
};
let RotationType = {
    type: "float",
    defaultValue: 0.0,
    blendOperation: "add"
};
let BodyInfo = {
    layerType: "Body",
    properties: {
        Head: RotationType,
        Torso: RotationType,
        Pelvis: RotationType,
        Tween
    },
    dofs: {
        topSection_r: true,
        middleSection_r: true,
        bottomSection_r: true
    }
};
class BodyLayer extends DOFBaseLayer_1.default {
    static getInfo() {
        return BodyInfo;
    }
    constructor() {
        super();
    }
    static generateDofs(props) {
        return {
            topSection_r: props.Head / 180 * Math.PI,
            middleSection_r: props.Torso / 180 * Math.PI,
            bottomSection_r: props.Pelvis / 180 * Math.PI
        };
    }
}
exports.default = BodyLayer;

},{"../bases/DOFBaseLayer":4}],9:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const EventBaseLayer_1 = require("../bases/EventBaseLayer");
let EventInfo = {
    layerType: "Event",
    properties: {
        Event: {
            type: "event",
            blendOperation: 'lastOneWins',
            defaultValue: {
                name: "",
                payload: ""
            }
        }
    }
};
/*
* Generic event layer with arbitrary payload data.
* */
class EventLayer extends EventBaseLayer_1.default {
    static getInfo() {
        return EventInfo;
    }
    constructor() {
        super();
    }
    static generateEvent(props) {
        let event = {
            name: ((props.Event.name.length === 0) ? "" : props.Event.name),
            payload: {}
        };
        // if it's a valid JSON, return the parsed object; otherwise, return
        // whatever the payload was
        if (props.Event.payload.length > 0) {
            try {
                event.payload = JSON.parse(props.Event.payload);
            }
            catch (error) {
                event.payload = props.Event.payload;
            }
        }
        return event;
    }
    static isValid(generatedEvent) {
        // only need valid name
        return (generatedEvent.name.length !== 0);
    }
}
exports.default = EventLayer;

},{"../bases/EventBaseLayer":5}],10:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const lodash_min_1 = require("lodash/lodash.min");
const DOFBaseLayer_1 = require("../bases/DOFBaseLayer");
const Conversion_1 = require("../utils/Conversion");
// Eye/Overlays
let centerX = 0;
let centerY = 0;
let eyeRadiusX = 300;
let eyeRadiusY = 300;
let values = [
    {
        display: 'linear',
        label: 'Linear Tween',
        value: 'linear'
    },
    {
        display: 'sine in',
        label: 'Sine Ease In',
        value: 'sineIn'
    },
    {
        display: 'sine out',
        label: 'Sine Ease Out',
        value: 'sineOut'
    },
    {
        display: 'sine in out',
        label: 'Sine Ease In Out',
        value: 'sineInOut'
    },
    {
        display: 'cubic in',
        label: 'Cubic Ease In',
        value: 'cubicIn'
    },
    {
        display: 'cubic out',
        label: 'Cubic Ease Out',
        value: 'cubicOut'
    },
    {
        display: 'cubic in out',
        label: 'Cubic Ease In Out',
        value: 'cubicInOut'
    }
];
let Tween = {
    type: {
        name: 'enum',
        values
    },
    defaultValue: values[3],
    blendOperation: 'none'
};
let VertexType = (xRelativeToCenter, yRelativeToCenter) => {
    return {
        type: "vector2",
        defaultValue: {
            x: xRelativeToCenter,
            y: yRelativeToCenter
        },
        blendOperation: "add"
    };
};
let Info = {
    properties: {
        Rotate: {
            type: "float",
            defaultValue: 0.0,
            blendOperation: "add"
        },
        Scale: {
            type: "vector2",
            defaultValue: {
                x: 1,
                y: 1
            },
            blendOperation: "multiply"
        },
        Translate: {
            type: "vector2",
            defaultValue: {
                x: centerX,
                y: centerY
            },
            blendOperation: "add"
        },
        Visible: {
            type: "bool",
            defaultValue: true,
            blendOperation: "lastOneWins"
        },
        Alpha: {
            type: "float",
            defaultValue: 1.0,
            blendOperation: "multiply"
        },
        Tween,
        "Vertex 1": VertexType(-eyeRadiusX, -eyeRadiusY),
        "Vertex 2": VertexType(0, -eyeRadiusY),
        "Vertex 3": VertexType(eyeRadiusX, -eyeRadiusY),
        "Vertex 4": VertexType(-eyeRadiusX, 0),
        "Vertex 5": VertexType(0, 0),
        "Vertex 6": VertexType(eyeRadiusX, 0),
        "Vertex 7": VertexType(-eyeRadiusX, eyeRadiusY),
        "Vertex 8": VertexType(0, eyeRadiusY),
        "Vertex 9": VertexType(eyeRadiusX, eyeRadiusY)
    }
};
class EyeAndOverlayLayer extends DOFBaseLayer_1.default {
    static get eyeRadiusY() {
        return eyeRadiusY;
    }
    static get eyeRadiusX() {
        return eyeRadiusX;
    }
    static _generateDofs(props, nameStem) {
        return {
            [nameStem + "vertexJoint1_t"]: Conversion_1.default.toMetersX(props['Vertex 1'].x) * props.Scale.x,
            [nameStem + "vertexJoint1_t_2"]: Conversion_1.default.toMetersY(props['Vertex 1'].y) * props.Scale.y,
            [nameStem + "vertexJoint2_t"]: Conversion_1.default.toMetersX(props['Vertex 2'].x) * props.Scale.x,
            [nameStem + "vertexJoint2_t_2"]: Conversion_1.default.toMetersY(props['Vertex 2'].y) * props.Scale.y,
            [nameStem + "vertexJoint3_t"]: Conversion_1.default.toMetersX(props['Vertex 3'].x) * props.Scale.x,
            [nameStem + "vertexJoint3_t_2"]: Conversion_1.default.toMetersY(props['Vertex 3'].y) * props.Scale.y,
            //
            [nameStem + "vertexJoint4_t"]: Conversion_1.default.toMetersX(props['Vertex 4'].x) * props.Scale.x,
            [nameStem + "vertexJoint4_t_2"]: Conversion_1.default.toMetersY(props['Vertex 4'].y) * props.Scale.y,
            [nameStem + "vertexJoint5_t"]: Conversion_1.default.toMetersX(props['Vertex 5'].x) * props.Scale.x,
            [nameStem + "vertexJoint5_t_2"]: Conversion_1.default.toMetersY(props['Vertex 5'].y) * props.Scale.y,
            [nameStem + "vertexJoint6_t"]: Conversion_1.default.toMetersX(props['Vertex 6'].x) * props.Scale.x,
            [nameStem + "vertexJoint6_t_2"]: Conversion_1.default.toMetersY(props['Vertex 6'].y) * props.Scale.y,
            //
            [nameStem + "vertexJoint7_t"]: Conversion_1.default.toMetersX(props['Vertex 7'].x) * props.Scale.x,
            [nameStem + "vertexJoint7_t_2"]: Conversion_1.default.toMetersY(props['Vertex 7'].y) * props.Scale.y,
            [nameStem + "vertexJoint8_t"]: Conversion_1.default.toMetersX(props['Vertex 8'].x) * props.Scale.x,
            [nameStem + "vertexJoint8_t_2"]: Conversion_1.default.toMetersY(props['Vertex 8'].y) * props.Scale.y,
            [nameStem + "vertexJoint9_t"]: Conversion_1.default.toMetersX(props['Vertex 9'].x) * props.Scale.x,
            [nameStem + "vertexJoint9_t_2"]: Conversion_1.default.toMetersY(props['Vertex 9'].y) * props.Scale.y
        };
    }
    static overrideProperties(newProps) {
        Object.assign(Info.properties, newProps);
    }
    static extend(input) {
        let result = lodash_min_1.merge({}, Info, input);
        return result;
    }
}
exports.default = EyeAndOverlayLayer;

},{"../bases/DOFBaseLayer":4,"../utils/Conversion":21,"lodash/lodash.min":undefined}],11:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const EyeAndOverlayLayer_1 = require("./EyeAndOverlayLayer");
const Conversion_1 = require("../utils/Conversion");
let EyeInfo = EyeAndOverlayLayer_1.default.extend({
    layerType: "Eye",
    dofs: {
        eyeSubRootBn_r: true,
        eyeSubRootBn_t: true,
        eyeSubRootBn_t_2: true,
        vertexJoint1_t: true,
        vertexJoint1_t_2: true,
        vertexJoint2_t: true,
        vertexJoint2_t_2: true,
        vertexJoint3_t: true,
        vertexJoint3_t_2: true,
        vertexJoint4_t: true,
        vertexJoint4_t_2: true,
        vertexJoint5_t: true,
        vertexJoint5_t_2: true,
        vertexJoint6_t: true,
        vertexJoint6_t_2: true,
        vertexJoint7_t: true,
        vertexJoint7_t_2: true,
        vertexJoint8_t: true,
        vertexJoint8_t_2: true,
        vertexJoint9_t: true,
        eyeVisibilityBn_r: true,
        eye_alphaChannelBn_r: true
    }
});
class EyeLayer extends EyeAndOverlayLayer_1.default {
    static getInfo() {
        return EyeInfo;
    }
    static get eyeRadiusX() {
        return EyeAndOverlayLayer_1.default.eyeRadiusX;
    }
    static get eyeRadiusY() {
        return EyeAndOverlayLayer_1.default.eyeRadiusY;
    }
    static generateDofs(props) {
        let dofs = EyeAndOverlayLayer_1.default._generateDofs(props, "");
        dofs.eyeSubRootBn_r = props.Rotate / 180 * Math.PI;
        dofs.eyeSubRootBn_t = Conversion_1.default.toMetersX(props.Translate.x);
        dofs.eyeSubRootBn_t_2 = Conversion_1.default.toMetersY(props.Translate.y);
        dofs.eyeVisibilityBn_r = props.Visible === undefined ? 1 : (props.Visible ? 1 : 0);
        dofs.eye_alphaChannelBn_r = props.Alpha === undefined ? 1 : props.Alpha;
        return dofs;
    }
}
exports.default = EyeLayer;

},{"../utils/Conversion":21,"./EyeAndOverlayLayer":10}],12:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const DOFBaseLayer_1 = require("../bases/DOFBaseLayer");
let EyeTextureInfo = {
    layerType: "Eye Texture",
    properties: {
        Texture: {
            type: "texture",
            defaultValue: "",
            blendOperation: "lastOneWins"
        },
        Color: {
            type: "rgb",
            defaultValue: {
                r: 255,
                g: 255,
                b: 255
            },
            blendOperation: "add"
        }
    },
    dofs: {
        eyeTextureInfixBn_r: true,
        eye_redChannelBn_r: true,
        eye_greenChannelBn_r: true,
        eye_blueChannelBn_r: true
    }
};
class EyeTextureLayer extends DOFBaseLayer_1.default {
    static getInfo() {
        return EyeTextureInfo;
    }
    constructor() {
        super();
    }
    static generateDofs(props) {
        return {
            eyeTextureInfixBn_r: props.Texture,
            eye_redChannelBn_r: props.Color.r / 255.0,
            eye_greenChannelBn_r: props.Color.g / 255.0,
            eye_blueChannelBn_r: props.Color.b / 255.0
        };
    }
}
exports.default = EyeTextureLayer;

},{"../bases/DOFBaseLayer":4}],13:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const DOFBaseLayer_1 = require("../bases/DOFBaseLayer");
let LEDInfo = {
    layerType: "LED",
    properties: {
        Color: {
            type: "rgb",
            defaultValue: {
                r: 0,
                g: 0,
                b: 0
            },
            blendOperation: "add"
        }
    },
    dofs: {
        lightring_redChannelBn_r: true,
        lightring_greenChannelBn_r: true,
        lightring_blueChannelBn_r: true
    }
};
class LEDLayer extends DOFBaseLayer_1.default {
    static getInfo() {
        return LEDInfo;
    }
    constructor() {
        super();
    }
    static generateDofs(props) {
        return {
            lightring_redChannelBn_r: props.Color.r / 255.0,
            lightring_greenChannelBn_r: props.Color.g / 255.0,
            lightring_blueChannelBn_r: props.Color.b / 255.0
        };
    }
}
exports.default = LEDLayer;

},{"../bases/DOFBaseLayer":4}],14:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const EyeAndOverlayLayer_1 = require("./EyeAndOverlayLayer");
const Conversion_1 = require("../utils/Conversion");
let OverlayInfo = EyeAndOverlayLayer_1.default.extend({
    layerType: "Overlay",
    properties: {
        Visible: {
            defaultValue: false
        }
    },
    dofs: {
        overlay_textureSubRootBn_r: true,
        overlay_textureSubRootBn_t: true,
        overlay_textureSubRootBn_t_2: true,
        overlay_vertexJoint1_t: true,
        overlay_vertexJoint1_t_2: true,
        overlay_vertexJoint2_t: true,
        overlay_vertexJoint2_t_2: true,
        overlay_vertexJoint3_t: true,
        overlay_vertexJoint3_t_2: true,
        overlay_vertexJoint4_t: true,
        overlay_vertexJoint4_t_2: true,
        overlay_vertexJoint5_t: true,
        overlay_vertexJoint5_t_2: true,
        overlay_vertexJoint6_t: true,
        overlay_vertexJoint6_t_2: true,
        overlay_vertexJoint7_t: true,
        overlay_vertexJoint7_t_2: true,
        overlay_vertexJoint8_t: true,
        overlay_vertexJoint8_t_2: true,
        overlay_vertexJoint9_t: true,
        overlay_alphaChannelBn_r: true,
        overlayVisibilityBn_r: true
    }
});
class OverlayLayer extends EyeAndOverlayLayer_1.default {
    static getInfo() {
        return OverlayInfo;
    }
    static generateDofs(props) {
        let dofs = EyeAndOverlayLayer_1.default._generateDofs(props, "overlay_");
        dofs.overlay_textureSubRootBn_r = props.Rotate / 180 * Math.PI;
        dofs.overlay_textureSubRootBn_t = Conversion_1.default.toMetersX(props.Translate.x);
        dofs.overlay_textureSubRootBn_t_2 = Conversion_1.default.toMetersY(props.Translate.y);
        dofs.overlayVisibilityBn_r = props.Visible === undefined ? 1 : (props.Visible ? 1 : 0);
        dofs.overlay_alphaChannelBn_r = props.Alpha === undefined ? 1 : props.Alpha;
        return dofs;
    }
}
exports.default = OverlayLayer;

},{"../utils/Conversion":21,"./EyeAndOverlayLayer":10}],15:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const DOFBaseLayer_1 = require("../bases/DOFBaseLayer");
let OverlayTextureInfo = {
    layerType: "Overlay Texture",
    properties: {
        Texture: {
            type: "texture",
            defaultValue: "",
            blendOperation: "lastOneWins"
        },
        Color: {
            type: "rgb",
            defaultValue: {
                r: 255,
                g: 255,
                b: 255
            },
            blendOperation: "add"
        }
    },
    dofs: {
        overlayTextureInfixBn_r: true,
        overlay_redChannelBn_r: true,
        overlay_greenChannelBn_r: true,
        overlay_blueChannelBn_r: true
    }
};
class OverlayTextureLayer extends DOFBaseLayer_1.default {
    static getInfo() {
        return OverlayTextureInfo;
    }
    constructor() {
        super();
    }
    static generateDofs(props) {
        return {
            overlayTextureInfixBn_r: props.Texture,
            overlay_redChannelBn_r: props.Color.r / 255.0,
            overlay_greenChannelBn_r: props.Color.g / 255.0,
            overlay_blueChannelBn_r: props.Color.b / 255.0
        };
    }
}
exports.default = OverlayTextureLayer;

},{"../bases/DOFBaseLayer":4}],16:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const EventBaseLayer_1 = require("../bases/EventBaseLayer");
let PixiInfo = {
    layerType: "Pixi",
    properties: {
        Pixi: {
            type: "pixi",
            defaultValue: "",
            blendOperation: "singleton"
        },
        "Attach To Eye": {
            type: "bool",
            defaultValue: false,
            blendOperation: "lastOneWins"
        },
        "Frame Offset": {
            type: "offset",
            defaultValue: "",
            blendOperation: "lastOneWins"
        }
    },
    dofs: {}
};
class PixiLayer extends EventBaseLayer_1.default {
    static getInfo() {
        return PixiInfo;
    }
    constructor() {
        super();
    }
    static generateEvent(props, layerNum) {
        return {
            name: "play-pixi",
            payload: {
                file: props.Pixi,
                layerNum,
                attach: props["Attach To Eye"],
                offset: props["Frame Offset"],
                effect: false // deprecated
            }
        };
    }
    static isValid(generatedEvent) {
        return ((generatedEvent.name === "play-pixi") &&
            (generatedEvent.payload.file.length > 0));
    }
}
exports.default = PixiLayer;

},{"../bases/EventBaseLayer":5}],17:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const DOFBaseLayer_1 = require("../bases/DOFBaseLayer");
let RefModes = [
    {
        display: 'Name',
        label: 'By Name',
        value: 'name'
    },
    {
        display: 'File Path',
        label: 'By File path',
        value: 'file'
    }
];
let ReferenceInfo = {
    layerType: "Reference",
    properties: {
        "ReferenceMode": {
            label: 'Type of Reference',
            type: {
                name: 'enum',
                values: RefModes
            },
            defaultValue: RefModes[0],
            blendOperation: 'none'
        },
        "KeysFileReference": {
            label: ' ',
            enumProperty: "ReferenceMode",
            type: "keysref",
            defaultValue: {
                file: "",
                name: "",
            }
        },
        "HoldFinalPose": {
            label: 'Hold Final Pose',
            type: "bool",
            defaultValue: true,
            blendOperation: "lastOneWins"
        }
    }
};
class ReferenceLayer extends DOFBaseLayer_1.default {
    static generateDofs() {
        return {};
    }
    static getInfo() {
        return ReferenceInfo;
    }
}
exports.default = ReferenceLayer;

},{"../bases/DOFBaseLayer":4}],18:[function(require,module,exports){
"use strict";
/**
 * Operations per property type for blending layers of properties together
 */
Object.defineProperty(exports, "__esModule", { value: true });
let operations = {
    lastOneWins: {
        texture(accumulated, newValue) {
            return newValue;
        },
        bool(accumulated, newValue) {
            return newValue;
        },
        event(accumulated, newValue) {
            return newValue;
        },
        audio(accumulated, newValue) {
            return newValue;
        }
    },
    add: {
        float(accumulated, newValue, defaultValue) {
            return accumulated + (newValue - defaultValue);
        },
        vector2(accumulated, newValue, defaultValue) {
            return {
                x: accumulated.x + (newValue.x - defaultValue.x),
                y: accumulated.y + (newValue.y - defaultValue.y)
            };
        },
        rgb(accumulated, newValue, defaultValue) {
            return {
                r: Math.max(0, Math.min(255, accumulated.r + (newValue.r - defaultValue.r))),
                g: Math.max(0, Math.min(255, accumulated.g + (newValue.g - defaultValue.g))),
                b: Math.max(0, Math.min(255, accumulated.b + (newValue.b - defaultValue.b)))
            };
        }
    },
    multiply: {
        float(accumulated, newValue) {
            return accumulated * newValue;
        },
        vector2(accumulated, newValue) {
            return {
                x: accumulated.x * newValue.x,
                y: accumulated.y * newValue.y
            };
        },
        rgb(accumulated, newValue) {
            return {
                r: Math.max(0, Math.min(255, accumulated.r * newValue.r)),
                g: Math.max(0, Math.min(255, accumulated.g * newValue.g)),
                b: Math.max(0, Math.min(255, accumulated.b * newValue.b))
            };
        }
    },
    singleton: {
        video(accumulated, newValue) {
            return newValue;
        }
    },
    inverse: {
        lastOneWins: {
            texture(accumulated) {
                return accumulated;
            },
            bool(accumulated) {
                return accumulated;
            }
        },
        singleton: {
            video(accumulated) {
                return accumulated;
            }
        },
        add: {
            float(accumulated, newValue, defaultValue) {
                return (newValue + defaultValue) - accumulated;
            },
            vector2(accumulated, newValue, defaultValue) {
                return {
                    x: (newValue.x + defaultValue.x) - accumulated.x,
                    y: (newValue.y + defaultValue.y) - accumulated.y
                };
            },
            rgb(accumulated, newValue, defaultValue) {
                return {
                    r: Math.max(0, Math.min(255, (newValue.r + defaultValue.r) - accumulated.r)),
                    g: Math.max(0, Math.min(255, (newValue.g + defaultValue.g) - accumulated.g)),
                    b: Math.max(0, Math.min(255, (newValue.b + defaultValue.b) - accumulated.b))
                };
            }
        },
        multiply: {
            float(accumulated, newValue) {
                return accumulated / newValue;
            },
            vector2(accumulated, newValue) {
                return {
                    x: newValue.x / accumulated.x,
                    y: newValue.y / accumulated.y
                };
            },
            rgb(accumulated, newValue) {
                return {
                    r: Math.max(0, Math.min(255, newValue.r / accumulated.r)),
                    g: Math.max(0, Math.min(255, newValue.g / accumulated.g)),
                    b: Math.max(0, Math.min(255, newValue.b / accumulated.b))
                };
            }
        }
    }
};
class BlendOperations {
    static inverse(operation, type) {
        // Operation none for any type is the same as lastOneWins for textures
        if (operation === 'none') {
            return operations.inverse.lastOneWins.texture;
        }
        else {
            return operations.inverse[operation][type];
        }
    }
    static normal(operation, type) {
        // Operation none for any type is the same as lastOneWins for textures
        if (operation === 'none') {
            return operations.lastOneWins.texture;
        }
        else {
            if (!(operation in operations)) {
                console.log(`operation ${operation} not found in ${Object.keys(operations)}`);
            }
            else {
                return operations[operation][type];
            }
        }
    }
}
exports.default = BlendOperations;

},{}],19:[function(require,module,exports){
"use strict";
/**
 * This file implements meta data associated with .keys and .anim files and conversions between them
 *  - mapping the internal animationutilities channel names to more user friendly
 *    names for display in the jibo animation tool and for developers who
 *    will be manipulating animation tool files themselves
 *  - information about converting between values in each file format. For example
 *    converting between radians and degrees for rotation angles
 */
Object.defineProperty(exports, "__esModule", { value: true });
// Animation robot DOFs and info (currently only includes layer type and display name;
// keeping as object in case we want other data here.
let dofInfo = {
    // BODY
    "topSection_r": {
        type: "Body",
        name: "Head"
    },
    "middleSection_r": {
        type: "Body",
        name: "Torso"
    },
    "bottomSection_r": {
        type: "Body",
        name: "Pelvis"
    },
    // EYE
    "eyeSubRootBn_r": {
        type: "Eye",
        name: "Rotate"
    },
    "eyeSubRootBn_t": {
        type: "Eye",
        name: "Translate"
    },
    "eyeSubRootBn_t_2": {
        type: "Eye",
        name: "Translate"
    },
    "vertexJoint1_t": {
        type: "Eye"
    },
    "vertexJoint1_t_2": {
        type: "Eye"
    },
    "vertexJoint2_t": {
        type: "Eye"
    },
    "vertexJoint2_t_2": {
        type: "Eye"
    },
    "vertexJoint3_t": {
        type: "Eye"
    },
    "vertexJoint3_t_2": {
        type: "Eye"
    },
    "vertexJoint4_t": {
        type: "Eye"
    },
    "vertexJoint4_t_2`": {
        type: "Eye"
    },
    "vertexJoint5_t": {
        type: "Eye"
    },
    "vertexJoint5_t_2": {
        type: "Eye"
    },
    "vertexJoint6_t": {
        type: "Eye"
    },
    "vertexJoint6_t_2": {
        type: "Eye"
    },
    "vertexJoint7_t": {
        type: "Eye"
    },
    "vertexJoint7_t_2": {
        type: "Eye"
    },
    "vertexJoint8_t": {
        type: "Eye"
    },
    "vertexJoint8_t_2": {
        type: "Eye"
    },
    "vertexJoint9_t": {
        type: "Eye"
    },
    "vertexJoint9_t_2": {
        type: "Eye"
    },
    // EYE TEXTURE
    "eyeTextureInfixBn_r": {
        type: "Eye Texture"
    },
    "eye_redChannelBn_r": {
        type: "Eye Texture"
    },
    "eye_greenChannelBn_r": {
        type: "Eye Texture"
    },
    "eye_blueChannelBn_r": {
        type: "Eye Texture"
    },
    // OVERLAY
    "overlay_textureSubRootBn_r": {
        type: "Overlay",
        name: "Rotate"
    },
    "overlay_textureSubRootBn_t": {
        type: "Overlay",
        name: "Translate"
    },
    "overlay_textureSubRootBn_t_2": {
        type: "Overlay",
        name: "Translate"
    },
    "overlay_vertexJoint1_t": {
        type: "Overlay"
    },
    "overlay_vertexJoint1_t_2": {
        type: "Overlay"
    },
    "overlay_vertexJoint2_t": {
        type: "Overlay"
    },
    "overlay_vertexJoint2_t_2": {
        type: "Overlay"
    },
    "overlay_vertexJoint3_t": {
        type: "Overlay"
    },
    "overlay_vertexJoint3_t_2": {
        type: "Overlay"
    },
    "overlay_vertexJoint4_t": {
        type: "Overlay"
    },
    "overlay_vertexJoint4_t_2": {
        type: "Overlay"
    },
    "overlay_vertexJoint5_t": {
        type: "Overlay"
    },
    "overlay_vertexJoint5_t_2": {
        type: "Overlay"
    },
    "overlay_vertexJoint6_t": {
        type: "Overlay"
    },
    "overlay_vertexJoint6_t_2": {
        type: "Overlay"
    },
    "overlay_vertexJoint7_t": {
        type: "Overlay"
    },
    "overlay_vertexJoint7_t_2": {
        type: "Overlay"
    },
    "overlay_vertexJoint8_t": {
        type: "Overlay"
    },
    "overlay_vertexJoint8_t_2": {
        type: "Overlay"
    },
    "overlay_vertexJoint9_t": {
        type: "Overlay"
    },
    "overlay_vertexJoint9_t_2": {
        type: "Overlay"
    },
    // OVERLAY TEXURE
    "overlayTextureInfixBn_r": {
        type: "Overlay Texture"
    },
    "overlay_redChannelBn_r": {
        type: "Overlay Texture"
    },
    overlay_greenChannelBn_r: {
        type: "Overlay Texture"
    },
    "overlay_blueChannelBn_r": {
        type: "Overlay Texture"
    },
    // BACKGROUND TEXTURE
    "screenBGTextureInfixBn_r": {
        type: "Background Texture"
    },
    "screenBG_redChannelBn_r": {
        type: "Background Texture"
    },
    "screenBG_greenChannelBn_r": {
        type: "Background Texture"
    },
    "screenBG_blueChannelBn_r": {
        type: "Background Texture"
    },
    // LED
    "lightring_redChannelBn_r": {
        type: "LED"
    },
    "lightring_greenChannelBn_r": {
        type: "LED"
    },
    "lightring_blueChannelBn_r": {
        type: "LED"
    }
};
class Channels {
    static dofNameToDisplayType(dofName) {
        return dofInfo[dofName].type;
    }
    static dofNameToDisplayName(dofName) {
        let displayName = dofInfo[dofName].name;
        return (displayName !== undefined) ? displayName : Channels.dofNameToDisplayType(dofName);
    }
    static displayNameToDof(displayName) {
        for (var dofName in dofInfo) {
            if (dofInfo[dofName].name === displayName) {
                return dofName;
            }
        }
        return;
    }
    static radiansToDegrees(radians) {
        return radians / Math.PI * 180;
    }
    static degreesToRadians(degree) {
        return degree / 180 * Math.PI;
    }
    static framesToSeconds(frame, frameRate) {
        return frame / frameRate;
    }
    static secondsToFrames(timeInSeconds, totalTimeInSeconds, totalFrames) {
        return Math.round(timeInSeconds / totalTimeInSeconds * (totalFrames));
    }
    static toTextureURL(jiboConfig, displayValue) {
        return this.baseTextureURL + this.getPaddedValueString(displayValue) + ".png";
    }
    static toBGTextureURL(jiboConfig, displayValue) {
        return this.baseBGURL + this.getPaddedValueString(displayValue) + ".png";
    }
}
exports.default = Channels;

},{}],20:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const hsv = require("color-space/hsv");
// function clampColorComponent(v){
//     return Math.floor(Math.max(0, Math.min(255, v)));
// }
/**
 * hsv value range is:
 *  h = [0,360],
 *  s = [0,100],
 *  v = [0,100]
 *
 * Uses range/values mapped out in this interface:
 * http://www.colorpicker.com/
 */
class Colors {
    static hsvToRgb(h, s, v) {
        let rgb = hsv.rgb([h, s, v]);
        return {
            r: rgb[0],
            g: rgb[1],
            b: rgb[2]
        };
    }
}
exports.default = Colors;

},{"color-space/hsv":undefined}],21:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const 
// These numbers come from here:
// https://github.jibo.com/sdk/geometry-config/blob/9206df71556c925876362abbd3c382a1e2923fea/P1.0/jibo.jscene#L10-L11
// They are computed based on the CAD model that we have in Maya and is used for exporting our 3D visualizers
// meshes
WIDTH_METERS = 0.13002148, HEIGHT_METERS = 0.073142126, WIDTH_PIXELS = 1280, HEIGHT_PIXELS = 720;
class Conversion {
    static toMetersX(xInPixels) {
        return (xInPixels) / WIDTH_PIXELS * WIDTH_METERS;
    }
    static toMetersY(yInPixels) {
        return (yInPixels) / HEIGHT_PIXELS * HEIGHT_METERS * -1;
    }
    static toPixelsX(xInMeters) {
        return xInMeters / WIDTH_METERS * WIDTH_PIXELS;
    }
    static toPixelsY(yInMeters) {
        return yInMeters / HEIGHT_METERS * HEIGHT_PIXELS * -1;
    }
}
exports.default = Conversion;

},{}],22:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const uuid = require("uuid");
class IDUtils {
    static create() {
        // I dislike the dashes, so I strip them out. This doesn't not affect
        // the chance of collisions over including them
        return uuid.v4().replace(/-/g, "");
    }
}
exports.default = IDUtils;

},{"uuid":undefined}],23:[function(require,module,exports){
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const path = require("path");
const fs = require("fs");
const Runtime_1 = require("../Runtime");
const JiboKeyframeInfo_1 = require("../JiboKeyframeInfo");
const jibo_plugins_1 = require("jibo-plugins");
/**
 * Keyframes Compositer: deep-copies the given keyframes structure and recursively composites any reference layers into it.
 * This is essentially the synchronous version of Jibo/src/rendering/tasks/KeysTask.ts.
 */
class KeyframesCompositer {
    /**
     * Constructor
     * @param {string} basepath the project root for the animation files being composited.
     * @param {string} [animdbPath] filename of the animDB.json files as an alternate to looking for it in
     * the project's node modules.
     * @param {string} [fileDir] the directory of the file being composited (needed when compositing frames since
     * we have no file to indicate what directory we're in).
     * @param {string} [assetPack] the asset pack the file is from.
     */
    constructor(basepath, animdbPath, fileDir, assetPack) {
        this.basepath = basepath;
        this.fileDir = fileDir;
        this.errors = [];
        this.hits = 0;
        this.misses = 0;
        this.noWarn = false;
        this.animDB = new miniAnimdb(basepath, animdbPath);
        this.cache = {};
        this.watchedFiles = {};
        this.assetPack = assetPack || '';
    }
    setNoWarn() {
        this.noWarn = true;
    }
    /**
     * Find all references within the keyframes and incorporate them (copies the data before compositing in references)
     * @param {Keyframes} frames -- deserialized .keys file (JSON "keyframes") object.
     * @returns {Keyframes} composited keyframes object.
     */
    getCompositedContentLayers(frames) {
        return this.getCompositedlayers(frames).contentLayers;
    }
    /**
     * Get the reference layers used during compositing. These are needed in order to find the
     * childPrefix associated with a particular reference. The childPrefix is used to find the audio layers
     * associated with a particular reference. All of this is done for the sake of displaying a waveform
     * within the reference layer in an animation editor timeline.
     * @param frames
     * @returns {Array}
     */
    getCompositedReferenceLayers(frames) {
        return this.getCompositedlayers(frames).referenceLayers;
    }
    getCompositedlayers(frames) {
        const inputString = JSON.stringify(frames);
        if (!(inputString in this.cache)) {
            frames = JSON.parse(inputString);
            this.cache[inputString] = this.processReferencesInKeyframes(frames, this.fileDir);
            const cacheEntries = Object.keys(this.cache).length;
            console.log(`Compositing cache now has ${cacheEntries} entries, hits/misses= ${this.hits / this.misses}`);
            this.misses++;
        }
        else {
            this.hits++;
        }
        return this.cache[inputString];
    }
    /**
     * Load the given keys file and all the references within it into a single object with all the layer references removed.
     * @param {string} url -- filename of file to load.
     * @returns {Keyframes} composited keyframes object.
     */
    compositeKeysfile(url) {
        const frames = Runtime_1.default.load(url, JiboKeyframeInfo_1.default);
        const dir = path.dirname(url);
        return this.processReferencesInKeyframes(frames, dir).contentLayers;
    }
    /**
     * Convert a [relative] file path reference or anim name reference into a full url.
     * @param {any} keyframe the keyframe containing the reference.
     * @param {string} refBase the directory of the file whose keyframe we are evaluating.
     * @returns {string} full resolved path to referenced file.
     */
    getReferencedUrl(keyframe, refBase) {
        let url;
        let assetPack;
        if (keyframe.value.ReferenceMode.value === 'name') {
            let name = keyframe.value.KeysFileReference.name;
            let anim = this.animDB.getAnimByName(name);
            if (!anim) {
                this.warn(`animdb name lookup failed on ${name}`);
            }
            else {
                // ResourceRoot is e.g. "/Users/eric/jibo/skills/template-6-is-best/node_modules/jibo-anim-db-animations"
                let parts = anim.resourceRoot.split('/node_modules/');
                // For future expansion -- when there is more than one animdb
                if (parts.length > 1) {
                    assetPack = parts[1];
                }
                else {
                    assetPack = 'project';
                }
                url = path.join(anim.resourceRoot, anim.meta.path);
            }
        }
        else {
            let filename = keyframe.value.KeysFileReference.file;
            assetPack = jibo_plugins_1.PathUtils.getAssetPack(filename);
            url = jibo_plugins_1.PathUtils.getAssetUri(filename, '', refBase);
        }
        return { url, assetPack };
    }
    /**
     * Process reference layers into normal keyframes.
     * @param {Keyframes} frames keyframes object to be composited.
     * @param {string} refBase the directory of the file whose keyframe we are evaluating.
     * @returns {Keyframes} contentLayers the composited keyframes object.
     * @returns {layer[]} referenceLayers the original reference layers from the keyframes object.
     */
    processReferencesInKeyframes(frames, refBase) {
        let contentLayers = this.dereferenceKeyframes(frames, refBase);
        this.removeHoldSafesInReferences(contentLayers);
        let referenceLayers = this.removeReferenceLayers(contentLayers);
        return { contentLayers, referenceLayers };
    }
    /**
     * Recursively load all referenced layers into the place(s) they were referenced in the referencing layers.
     * Layers pulled in by reference will be bounded by either the end of the overall file or the next reference
     * in the layer.
     * @param {Keyframes} frames keyframes object to be composited.
     * @param {string} refBase the directory of the file whose keyframe we are evaluating.
     * @returns {Keyframes} composited keyframes object.
     */
    dereferenceKeyframes(frames, refBase) {
        const fileRefs = this.getKeyFileReferences(frames, refBase);
        for (let ref of fileRefs) {
            if (!fs.existsSync(ref.url) || !fs.statSync(ref.url).isFile()) {
                this.warn(`Could not find referenced keys file ${ref.url} -- ignored.`);
                continue;
            }
            ref.frames = this.nestedLoad(ref.url, ref.assetPack, ref.parentId);
            let validUpto = ref.holdFinalPose ? ref.nextRefStart : ref.timeOffset + ref.frames.duration;
            this.timeshift(ref.frames, ref.timeOffset, validUpto, ref.containerDuration - 1);
            this.composite(ref.layerNumber, frames, ref.frames);
        }
        return frames;
    }
    /**
     * Given a keys file url, load the file and then recursively
     * composite into it any keys files it points to (somewhat like macro expansion).
     * Returns the result of the compositing operation with all reference layers removed.
     * @param {string} url file to load.
     * @param {string} prefix layerID(s) of referencing layer.
     * @returns {Keyframes} composited keyframes object.
     */
    nestedLoad(url, assetPack, prefix) {
        const frames = Runtime_1.default.load(url, JiboKeyframeInfo_1.default);
        const dir = path.dirname(url);
        this.resolveAssetRefs(frames, assetPack);
        this.watchForChanges(url);
        if (this.hasCircularReference(frames, prefix)) {
            this.warn(`Circular reference detected in file: ${url}`);
            return frames;
        }
        this.fixLayerIds(frames, prefix);
        return this.dereferenceKeyframes(frames, dir);
    }
    /**
     * Convert keyframes referencing texture, pixi and audio information into assetpack style references if necessary.
     *
     * The motivation:
     * Consider a reference layer in a skill's animation that references an animDB keys file.
     * Compositing will pull in the layers from the animDB keys file, but any asset references (textures, audio, pixi)
     * in those layers will be relative to the animDB root. If the paths to those assets are not converted to
     * asset-pack style references (while we know their provenance) we will not be able to distinguish later on
     * whether those references are relative to the animDB or to the local skill.
     *
     * @param {Keyframes} frames the keyframes object whose asset references will be modified.
     * @param {string} assetPack the assetPack that the containing file is in.
     */
    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);
                    }
                }
            }
        }
    }
    /**
     * Find all references in a keyfile, returning them in reverse-order.
     * @param {Keyframes}
     * @param {string} refBase the directory of the file that contained the keyframes.
     * @returns {Array<Object>} array of objects describing the reference layers found.
     */
    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++) {
                    let keyframe = layer.keyframes[keyi];
                    let atEnd = layer.keyframes.length === keyi + 1;
                    let nextRefStart = atEnd ? Infinity : layer.keyframes[keyi + 1].time;
                    let { url, assetPack } = this.getReferencedUrl(keyframe, refBase);
                    keyframe.childPrefix = `${layer.id}-${this.zeroPad(keyi, 2)}`;
                    if (url) {
                        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;
    }
    /**
     * Place num in a leading-zero-padded field of the given size
     * @param {number} num Number to pad
     * @param {number} size Size of final field
     * @returns {string}
     */
    zeroPad(num, size) {
        return (1e15 + num + "").slice(-size);
    }
    /**
     * Find any "HOLD_SAFE" events in referenced layers and remove them.
     * @param {Keyframes} frames keyframes to be cleaned
     */
    removeHoldSafesInReferences(frames) {
        for (let layer of frames.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';
                    }
                }
            }
        }
    }
    /**
     * Removes all reference-type layers within the given keysfile
     * and return them.
     * @param {Keyframes} frames
     */
    removeReferenceLayers(frames) {
        let referenceLayers = [];
        for (let i = 0; i < frames.layers.length; i++) {
            const layer = frames.layers[i];
            if (layer.type === 'Reference') {
                referenceLayers.push(frames.layers.splice(i--, 1)[0]);
            }
        }
        return referenceLayers;
    }
    /**
     * Shift the timepoint of all the keyframes within each of the given layers by the given timeOffset.
     * validFrom and validUpto are in "referencing" layer coordinates.
     * @param {Keyframes} frames
     * @param {number} validFrom the beginning of the valid region.
     * @param {number} validUpto the ending of valid region, or Infinity for unlimited. The layer will not be included in renderings after this point.
     * @param {number} holdAfter the latest timepoint in the layer that will be rendered (regardless of the actual time requested).
     */
    timeshift(frames, validFrom, validUpto, holdAfter) {
        for (let layer of frames.layers) {
            if (layer.validFrom === undefined) {
                // Initialize all not-yet-bounded layers.
                layer.validFrom = validFrom;
                layer.validUpto = validUpto;
                layer.holdAfter = holdAfter;
            }
            else {
                // Shift the valid region of previously bounded layers.
                layer.validFrom += validFrom;
                layer.validUpto += validFrom;
                layer.holdAfter += validFrom;
            }
            // Limit a layer's end time if it exceeds the requested end time.
            if (layer.validUpto > validUpto) {
                layer.validUpto = validUpto;
            }
            // Limit a layer's hold after point if it exceeds the requested one.
            if (layer.holdAfter > holdAfter) {
                layer.holdAfter = holdAfter;
            }
            // Shift the individual keyframes over by the new start point.
            for (let keyframe of layer.keyframes) {
                keyframe.time += validFrom;
            }
        }
    }
    /**
     * Insert all the layers of the toBeInsertedFrames into existingFrames at the given layer number.
     * Insert them last-first in order to preserve their original ordering at the designated layer.
     * @param {number} layerNumber
     * @param {Keyframes} existingFrames
     * @param {Keyframes} toBeInsertedFrames
     */
    composite(layerNumber, existingFrames, toBeInsertedFrames) {
        for (let i = toBeInsertedFrames.layers.length - 1; i >= 0; i--) {
            existingFrames.layers.splice(layerNumber, 0, toBeInsertedFrames.layers[i]);
        }
    }
    /**
     * Modifies the layer ids to prefixed by the referencing layer's id (delimited by "-")
     * and suffixed with the layer number (delimited by '.').
     * @param {Keyframes} frames
     * @param {string} prefix
     */
    fixLayerIds(frames, prefix) {
        let i = 0;
        for (let layer of frames.layers) {
            layer.id = `${prefix}-${layer.id}.${i}`;
            i++;
        }
    }
    /**
     * Was this layer produced from a keyframes reference?
     * @param layer
     * @returns {boolean}
     */
    isReferencedLayer(layer) {
        return layer.id.indexOf('-') >= 0;
    }
    /**
     * Return true if frame being referenced already exists in hierarchy.
     * @param frames
     * @param prefix
     */
    hasCircularReference(frames, prefix) {
        for (let layer of frames.layers) {
            if (prefix.indexOf(layer.id) >= 0) {
                return true;
            }
        }
        return false;
    }
    /**
     * Convert a non-asset pack reference into an asset-pack one.
     * @param assetPack
     * @param filepath
     * @returns {string}
     */
    convertToAssetReference(assetPack, filepath) {
        const ASSETPACK_DELIMITER = '://';
        if (filepath && filepath.indexOf(ASSETPACK_DELIMITER) !== -1) {
            // Don't touch paths that already reference asset packs.
            return filepath;
        }
        return assetPack + ASSETPACK_DELIMITER + filepath;
    }
    watchForChanges(url) {
        if (url in this.watchedFiles) {
            return;
        }
        this.watchedFiles[url] = true;
        fs.watch(url, (event, filename) => {
            this.cache = {};
            console.log(`File ${filename} had event: ${event} `);
        });
    }
    warn(error) {
        if (this.errors.indexOf(error) === -1) {
            this.errors.push(error);
        }
        if (!this.noWarn) {
            console.warn(error);
        }
    }
}
exports.default = KeyframesCompositer;
/**
 * Poor man's animDB -- only supports name lookup.
 */
class miniAnimdb {
    constructor(basepath, animdbPath) {
        if (!animdbPath) {
            animdbPath = path.join(basepath, 'animdb.json');
            if (!fs.existsSync(animdbPath)) {
                animdbPath = path.join(basepath, 'node_modules/jibo-anim-db-animations/animdb.json');
            }
        }
        if (!fs.existsSync(animdbPath)) {
            console.warn(`No animdb found at ${animdbPath}, reference layers by name will fail.`);
        }
        else {
            this.basepath = path.dirname(animdbPath);
            this.animdb = JSON.parse(fs.readFileSync(animdbPath, 'utf8'));
            // Make lower case versions of the keys
            for (let key in this.animdb) {
                this.animdb[key.toLowerCase()] = this.animdb[key];
            }
        }
    }
    getAnimByName(name) {
        let key = name.toLowerCase();
        if (this.animdb && key in this.animdb) {
            return { meta: { path: this.animdb[key].path }, resourceRoot: this.basepath };
        }
    }
}

},{"../JiboKeyframeInfo":1,"../Runtime":2,"fs":undefined,"jibo-plugins":undefined,"path":undefined}],24:[function(require,module,exports){
"use strict";
// Initialize the data with a default set of values for the necessary channels to have jibo animating his top, middle, and bottom body rotations.
// This includes some eye and overlay texture related default values in order to make sure Jibo's eye is showing centered on his screen
Object.defineProperty(exports, "__esModule", { value: true });
const fs = require("fs");
const path = require("path");
const hash = require("object-hash");
const JiboKeyframeInfo_1 = require("../JiboKeyframeInfo");
const Channels_1 = require("./Channels");
const Runtime_1 = require("../Runtime");
class KeysUtils {
    /**
     * Load a keys file asynchronously and create an anim object from it.
     * @deprecated Use jibo.rendering.animation.KeysLoader  -- this version does NOT composite reference layers.
     * @param keysPath
     * @param cb
     */
    static keysToAnimObjectAsync(keysPath, cb) {
        fs.readFile(keysPath, 'utf8', (err, data) => {
            if (err) {
                console.log("\nError parsing \"" + keysPath + "\". " + err + "\n");
                cb(null);
            }
            else {
                let keysData = JSON.parse(data);
                JiboKeyframeInfo_1.default.onLoad(keysData);
                // use the base name of the uri for the anim data "name"
                let baseName = path.basename(keysPath);
                let animObj = KeysUtils.keysObjToAnimObject(keysData, baseName);
                cb(animObj);
            }
        });
    }
    /**
     * Load a keys file synchronously.
     * @deprecated Use jibo-keyframes.utils.KeyframesCompositer -- this version does NOT composite reference layers.
     * @returns {*}
     */
    static keysToAnimObject(keysPath) {
        let keysData;
        try {
            // Load .keys file
            keysData = JSON.parse(fs.readFileSync(keysPath, 'utf8'));
        }
        catch (error) {
            console.log("\nError parsing \"" + keysPath + "\". " + error + "\n");
            process.exit(1);
        }
        // use the base name of the uri for the anim data "name"
        let baseName = path.basename(keysPath);
        return KeysUtils.keysObjToAnimObject(keysData, baseName);
    }
    /**
     * Write out an .anim file created from a .keys file.
     * @deprecated this version does NOT composite reference layers.
     * @param keysPath
     * @param animPath
     */
    static keysToAnim(keysPath, animPath) {
        console.log(keysPath);
        let animData = KeysUtils.keysToAnimObject(keysPath);
        try {
            fs.writeFileSync(animPath, JSON.stringify(animData, null, '    '), 'utf8');
        }
        catch (error) {
            console.log("\nERROROROROROR\n");
            process.exit(1);
        }
    }
    /**
     * Given a keysfile path, see if there is an .anim file that has been made from it and asynchronously return that.
     * @param keysFile
     * @param cb
     */
    static getCachedAnimForKeysAsync(keysFile, cb) {
        let animFile = KeysUtils.keysPathToAnimPath(keysFile);
        if (fs.existsSync(animFile) && fs.statSync(animFile).mtime >= fs.statSync(keysFile).mtime) {
            fs.readFile(animFile, 'utf8', (err, data) => {
                if (err) {
                    return cb(err);
                }
                let animData = JSON.parse(data);
                cb(null, animData);
            });
        }
        else {
            cb(null, null);
        }
    }
    /**
     * Given a keysfile path, see if there is an .anim file that has been made from it and return that.
     * @param keysFile
     */
    static getCachedAnimForKeys(keysFile) {
        let animFile = KeysUtils.keysPathToAnimPath(keysFile);
        if (fs.existsSync(animFile) && fs.statSync(animFile).mtime >= fs.statSync(keysFile).mtime) {
            let data = fs.readFileSync(animFile, 'utf8');
            let animData = JSON.parse(data);
            return animData;
        }
    }
    /**
     * Given a keysfile in memory (and the filename from which it came) asynchronously return an anim object.
     * @param keysData
     * @param filename
     * @param cb
     */
    static keysObjToAnimObjectAsync(keysData, filename, options, cb) {
        JiboKeyframeInfo_1.default.onLoad(keysData);
        KeysUtils.getCachedAnimForKeysAsync(filename, (err, cachedData) => {
            if (err) {
                return cb(err);
            }
            if (!cachedData) {
                cachedData = KeysUtils.computeAnimObject(keysData, filename);
            }
            if (options) {
                KeysUtils.transformAnimObject(options, cachedData);
            }
            cb(null, cachedData);
        });
    }
    /**
     * Given a keysfile in memory (and the filename from which it came) return an anim object.
     * @param keysData
     * @param filename
     * @returns {null}
     */
    static keysObjToAnimObject(keysData, filename) {
        JiboKeyframeInfo_1.default.onLoad(keysData);
        let cachedData = filename ? KeysUtils.getCachedAnimForKeys(filename) : null;
        if (!cachedData) {
            cachedData = KeysUtils.computeAnimObject(keysData, filename);
        }
        return cachedData;
    }
    static keysPathToAnimPath(keysfile) {
        return keysfile.replace(/\.keys$/, '.anim');
    }
    static getCacheFileNameIfAvailable(keysfile, cacheExt, cb) {
        let cacheFile = keysfile.replace(/\.keys$/, cacheExt);
        fs.stat(cacheFile, (err, stats) => {
            if (err) {
                return cb(null, null);
            }
            let cacheMtime = stats.mtime;
            fs.stat(keysfile, (err, stats) => {
                if (err) {
                    return cb(err);
                }
                let keysMtime = stats.mtime;
                cb(null, (cacheMtime >= keysMtime) ? cacheFile : null);
            });
        });
    }
    static getAnimFilePath(keysfile, cb) {
        KeysUtils.getCacheFileNameIfAvailable(keysfile, '.anim', cb);
    }
    static getAssetsFilePath(keysfile, cb) {
        KeysUtils.getCacheFileNameIfAvailable(keysfile, '.assets', cb);
    }
    /**
     * Convert keysData into an animData object
     * @param keysData
     * @param filename
     * @returns {{header: {fileType: string, version, creationTime: number}, content: {name, channels: Array, events: Array}}}
     */
    static computeAnimObject(keysData, filename) {
        var animData = {
            header: {
                fileType: "Animation",
                version: keysData.version,
                // Add animdb object hash metadata so that the .anim file changes in the case that its
                // containing .keys file only changes in its animdb field (which isn't otherwise picked up)
                animdb: keysData.animdb ? hash(keysData.animdb) : hash({})
            },
            content: {
                name: filename ? path.parse(filename).base : '',
                channels: [],
                events: []
            }
        };
        let animChannels = {};
        // For each frame calculate all dof and event values and save them to file
        for (let frame = 0; frame < keysData.duration; frame++) {
            let timeInSeconds = Channels_1.default.framesToSeconds(frame, keysData.framerate);
            let dofs = Runtime_1.default.evaluateAllDOFLayers(keysData, JiboKeyframeInfo_1.default, timeInSeconds);
            let events = Runtime_1.default.evaluateAllEventLayers(keysData, JiboKeyframeInfo_1.default, timeInSeconds);
            for (let dofName in dofs) {
                if (typeof animChannels[dofName] === "undefined") {
                    animChannels[dofName] = {
                        dofName: dofName,
                        length: keysData.duration / keysData.framerate,
                        times: [timeInSeconds],
                        values: [dofs[dofName]]
                    };
                    animData.content.channels.push(animChannels[dofName]);
                }
                else {
                    let values = animChannels[dofName].values;
                    let times = animChannels[dofName].times;
                    let value = dofs[dofName];
                    // *** DOF KOMPRESSOR ***
                    // Here we compress each channel's DOFs in a way that is transparent to the rendering system.
                    // Do the prior two frames in this channel have the same value as the new one we're adding?
                    // If so we don't add a further time/value frame but rather update the last frame's time to the current time.
                    // This "hollows out" the inner frames from a run of frames that would otherwise all have the same value.
                    let svalue = `${value}`;
                    let length = values.length;
                    if (length >= 2 && `${values[length - 1]}` === svalue && `${values[length - 2]}` === svalue) {
                        times.pop();
                        values.pop();
                    }
                    times.push(timeInSeconds);
                    values.push(value);
                }
            }
            for (let i = 0; i < events.length; i++) {
                let animEvent = {
                    time: timeInSeconds,
                    eventName: events[i].name,
                    payload: events[i].payload
                };
                animData.content.events.push(animEvent);
            }
        }
        return animData;
    }
}
exports.default = KeysUtils;

},{"../JiboKeyframeInfo":1,"../Runtime":2,"./Channels":19,"fs":undefined,"object-hash":undefined,"path":undefined}],25:[function(require,module,exports){
"use strict";
/**
 * keyframes entry point.
 */
Object.defineProperty(exports, "__esModule", { value: true });
/**
 * This assumes that some higher level logic has already determined that the currentTime is between the first
 * and last keyframe's times.
 * That is, do not call this with a currentTime < first-keyframe-time or currentTime >= last-keyframe-time.
 * Returns: start-keyframe-idx and end-keyframe-idx where: start-keyframe-time <= currentTime < end-keyframe-time
 */
class Search {
    static keyframeSearch(keyframes, currentTime) {
        let lo = 0, hi = keyframes.length - 2, mid /*,
        steps = 0*/;
        while (lo <= hi) {
            mid = Math.floor((lo + hi) / 2);
            //steps++;
            //console.log(`mid: ${mid}, lo: ${lo}, hi: ${hi} start: ${keyframes[mid].time}, end: ${keyframes[mid+1].time}`)
            if (currentTime >= keyframes[mid + 1].time) {
                //console.log('moving up');
                lo = mid + 1;
            }
            else if (currentTime < keyframes[mid].time) {
                //console.log('moving down');
                hi = mid - 1;
            }
            else {
                //console.log(`steps: ${steps}`);
                return {
                    start: mid,
                    end: mid + 1
                };
            }
        }
    }
    static keyframeSearchAbsolute(keyframes, keyframeTime) {
        if (keyframes.length === 0) {
            return undefined;
        }
        let lo = 0;
        let hi = keyframes.length - 1;
        let mid;
        while (lo <= hi) {
            mid = Math.floor((lo + hi) / 2);
            let midTime = keyframes[mid].time;
            if (keyframeTime === midTime) {
                return mid; // found it
            }
            else if (keyframeTime > midTime) {
                // if our time is greater, then move up
                lo = mid + 1;
            }
            else {
                // if our time is less, then move down
                hi = mid - 1;
            }
        }
        // not found
        return undefined;
    }
}
exports.default = Search;

},{}],26:[function(require,module,exports){
"use strict";
/**
 * A set of functions for blending between a start and end keyframe for a
 * variety of value types. The name of the function matches the value type
 * it knows how to blend
 */
Object.defineProperty(exports, "__esModule", { value: true });
/**
 * These are the set of easing functions our animation system supports. They
 * are used by the animation system to create variations of speed, acceleration,
 * overshooting, and undershooting of blending values.
 *
 * The `t` variable passed to each easing function has the value range: [0,1]. The
 * functions each return a float that should be used to create the usual weighted
 * blend of two values to be tweened. Example
 *
 * tweenFloats(start, end, t) {
 *   let f = easing.linear(t);
 *   return start*(1-f) + end*f;
 * }
 */
const lodash_min_1 = require("lodash/lodash.min");
const easesFunctions = require("eases");
/**
 * For now we support all of the easing functions in 'eases' module.
 * There's some good stuff here: http://www.rich-harris.co.uk/ramjet/
 */
let easing = lodash_min_1.clone(easesFunctions);
/**
 * "snap" always returns a weight fully weighted to the last keyframe
 */
easing.snap = () => 0;
class Tweening {
    /**
     * getEasingFunc - Resolve which easing function is desired
     *
     * @param  {function|string} easingFuncOrString function or name of a built-in easing function that calculates the blending weights
     * @return {function} the resolved easing function
     */
    static getEasingFunc(easingFuncOrString) {
        if (typeof easingFuncOrString === "function") {
            return easingFuncOrString;
        }
        else {
            return easing[easingFuncOrString];
        }
    }
    /**
     * @param {number} start - Start value
     * @param {number} end - End Value
     * @param {number} time - time between [0,1] indicating where in a blend we are
     * @param {function|string} easing function or name of a built-in easing function that calculates the blending weights
     */
    static float(start, end, time, easing) {
        let f = Tweening.getEasingFunc(easing)(time);
        return start * (1 - f) + end * f;
    }
    /**
     * @param {object} start - Start value
     * @param {object} end - End Value
     * @param {number} time - time between [0,1] indicating where in a blend we are
     * @param {function|string} easing function or name of a built-in easing function that calculates the blending weights
     */
    static vector2(start, end, time, easing) {
        let f = Tweening.getEasingFunc(easing)(time);
        return {
            x: start.x * (1 - f) + end.x * f,
            y: start.y * (1 - f) + end.y * f
        };
    }
    /**
     * @param {object} start - Start value
     * @param {object} end - End Value
     * @param {number} time - time between [0,1] indicating where in a blend we are
     * @param {function|string} easing function or name of a built-in easing function that calculates the blending weights
     */
    static rgb(start, end, time, easing) {
        let f = Tweening.getEasingFunc(easing)(time);
        return {
            r: start.r * (1 - f) + end.r * f,
            g: start.g * (1 - f) + end.g * f,
            b: start.b * (1 - f) + end.b * f
        };
    }
    /**
     * @param {number} start - Start value
     * @param {number} end - End Value
     * @param {number} time - time between [0,1] indicating where in a blend we are
     * @param {function|string} easing function or name of a built-in easing function that calculates the blending weights
     */
    static color(start, end, time /*, easing*/) {
        let f = Tweening.getEasingFunc("linear")(time);
        return start * (1 - f) + end * f;
    }
    static texture(start /*, end, time, easing*/) {
        return start;
    }
    static video(start /*, end, time, easing*/) {
        return start;
    }
    static bool(start) {
        return start;
    }
    static enum(start /*, end, time, easing*/) {
        return start;
    }
    static pixi(start) {
        return start;
    }
    static keysref(start) {
        return start;
    }
}
exports.default = Tweening;

},{"eases":undefined,"lodash/lodash.min":undefined}],27:[function(require,module,exports){
"use strict";
/**
 * keyframes entry point.
 */
const KeysUtils_1 = require("./utils/KeysUtils");
const Channels_1 = require("./utils/Channels");
const IDUtils_1 = require("./utils/IDUtils");
const Conversion_1 = require("./utils/Conversion");
const Search_1 = require("./utils/Search");
const Tweening_1 = require("./utils/Tweening");
const JiboKeyframeInfo_1 = require("./JiboKeyframeInfo");
const KeyframesCompositer_1 = require("./utils/KeyframesCompositer");
const Runtime_1 = require("./Runtime");
module.exports = {
    JiboKeyframeInfo: JiboKeyframeInfo_1.default,
    KeyframesCompositer: KeyframesCompositer_1.default,
    keysToAnimObject: KeysUtils_1.default.keysToAnimObject,
    keysToAnimObjectAsync: KeysUtils_1.default.keysToAnimObjectAsync,
    keysObjToAnimObjectAsync: KeysUtils_1.default.keysObjToAnimObjectAsync,
    keysObjToAnimObject: KeysUtils_1.default.keysObjToAnimObject,
    computeAnimObject: KeysUtils_1.default.computeAnimObject,
    getAnimFilePath: KeysUtils_1.default.getAnimFilePath,
    getAssetsFilePath: KeysUtils_1.default.getAssetsFilePath,
    keysToAnim: KeysUtils_1.default.keysToAnim,
    search: Search_1.default,
    tweening: Tweening_1.default,
    runtime: Runtime_1.default,
    channels: Channels_1.default,
    generateId: IDUtils_1.default.create,
    conversion: Conversion_1.default
};

},{"./JiboKeyframeInfo":1,"./Runtime":2,"./utils/Channels":19,"./utils/Conversion":21,"./utils/IDUtils":22,"./utils/KeyframesCompositer":23,"./utils/KeysUtils":24,"./utils/Search":25,"./utils/Tweening":26}]},{},[27])(27)
});

//# sourceMappingURL=jibo-keyframes.js.map