popmotion.global.js

/******/ (function(modules) { // webpackBootstrap
/******/ 	// The module cache
/******/ 	var installedModules = {};
/******/
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/
/******/ 		// Check if module is in cache
/******/ 		if(installedModules[moduleId])
/******/ 			return installedModules[moduleId].exports;
/******/
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = installedModules[moduleId] = {
/******/ 			exports: {},
/******/ 			id: moduleId,
/******/ 			loaded: false
/******/ 		};
/******/
/******/ 		// Execute the module function
/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
/******/
/******/ 		// Flag the module as loaded
/******/ 		module.loaded = true;
/******/
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/
/******/
/******/ 	// expose the modules object (__webpack_modules__)
/******/ 	__webpack_require__.m = modules;
/******/
/******/ 	// expose the module cache
/******/ 	__webpack_require__.c = installedModules;
/******/
/******/ 	// __webpack_public_path__
/******/ 	__webpack_require__.p = "";
/******/
/******/ 	// Load entry module and return exports
/******/ 	return __webpack_require__(0);
/******/ })
/************************************************************************/
/******/ ([
/* 0 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var popmotion = __webpack_require__(1),
	    UIref = window.ui;
	
	window.ui = window.popmotion = popmotion;
	
	/*
	    If noConflict is run, the original reference to window.UI is
	    restored and Popmotion is loaded to window.Popmotion
	*/
	window.ui.noConflict = function () {
	    window.ui = UIref;
	};

/***/ },
/* 1 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var popmotion = __webpack_require__(2);
	
	/*
	    Add optional custom value type support
	*/
	popmotion.addValueType({
	    alpha: __webpack_require__(3),
	    angle: __webpack_require__(4),
	    px: __webpack_require__(5),
	    hsl: __webpack_require__(6),
	    rgb: __webpack_require__(7),
	    hex: __webpack_require__(8),
	    color: __webpack_require__(9),
	    positions: __webpack_require__(10),
	    dimensions: __webpack_require__(11),
	    scale: __webpack_require__(12),
	    shadow: __webpack_require__(13),
	    complex: __webpack_require__(14)
	});
	
	/*
	    Predefined roles
	*/
	
	popmotion.attr = __webpack_require__(15);
	popmotion.css = __webpack_require__(16);
	popmotion.svg = __webpack_require__(17);
	popmotion.drawPath = __webpack_require__(18);
	
	module.exports = popmotion;

/***/ },
/* 2 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var valueTypeManager = __webpack_require__(19),
	    Popmotion = {
	
	    Actor: __webpack_require__(20),
	
	    Sequence: __webpack_require__(21),
	
	    Input: __webpack_require__(22),
	
	    Iterator: __webpack_require__(23),
	
	    Process: __webpack_require__(24),
	
	    Easing: __webpack_require__(26),
	
	    Role: __webpack_require__(25),
	
	    Action: __webpack_require__(27),
	    Tween: __webpack_require__(28),
	    Simulate: __webpack_require__(29),
	    Track: __webpack_require__(30),
	
	    /*
	        Create an Iterator of Actors with selected dom elements
	    */
	    select: __webpack_require__(31),
	
	    addValueType: function addValueType() {
	        valueTypeManager.extend.apply(valueTypeManager, arguments);
	        return this;
	    },
	
	    calc: __webpack_require__(32)
	};
	
	module.exports = Popmotion;

/***/ },
/* 3 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	module.exports = {
	    defaultProps: {
	        min: 0,
	        max: 1
	    }
	};

/***/ },
/* 4 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	module.exports = {
	    defaultProps: {
	        unit: 'deg'
	    }
	};

/***/ },
/* 5 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	module.exports = {
	    defaultProps: {
	        unit: 'px'
	    }
	};

/***/ },
/* 6 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var createDelimited = __webpack_require__(33),
	    getColorValues = __webpack_require__(34),
	    functionCreate = __webpack_require__(35),
	    defaultProps = __webpack_require__(36),
	    terms = __webpack_require__(37).hsl;
	
	module.exports = {
	
	    defaultProps: {
	        Hue: {
	            min: 0,
	            max: 360
	        },
	        Saturation: defaultProps.percent,
	        Lightness: defaultProps.percent,
	        Alpha: defaultProps.opacity
	    },
	
	    test: function test(value) {
	        return value && value.indexOf('hsl') > -1;
	    },
	
	    split: function split(value) {
	        return getColorValues(value, terms);
	    },
	
	    combine: function combine(values) {
	        return functionCreate(createDelimited(values, terms, ', ', 2), 'hsla');
	    }
	};

/***/ },
/* 7 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var createDelimited = __webpack_require__(33),
	    getColorValues = __webpack_require__(34),
	    functionCreate = __webpack_require__(35),
	    defaultProps = __webpack_require__(36),
	    colorDefaults = defaultProps.color,
	    terms = __webpack_require__(37).colors;
	
	module.exports = {
	
	    defaultProps: {
	        Red: colorDefaults,
	        Green: colorDefaults,
	        Blue: colorDefaults,
	        Alpha: defaultProps.opacity
	    },
	
	    test: function test(value) {
	        return value && value.indexOf('rgb') > -1;
	    },
	
	    split: function split(value) {
	        return getColorValues(value, terms);
	    },
	
	    combine: function combine(values) {
	        return functionCreate(createDelimited(values, terms, ', ', 2), 'rgba');
	    }
	};

/***/ },
/* 8 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var rgb = __webpack_require__(7);
	
	module.exports = {
	
	    defaultProps: rgb.defaultProps,
	
	    test: function test(value) {
	        return value && value.indexOf('#') > -1;
	    },
	
	    split: function split(value) {
	        var r, g, b;
	
	        // If we have 6 characters, ie #FF0000
	        if (value.length > 4) {
	            r = value.substr(1, 2);
	            g = value.substr(3, 2);
	            b = value.substr(5, 2);
	
	            // Or we have 3 characters, ie #F00
	        } else {
	                r = value.substr(1, 1);
	                g = value.substr(2, 1);
	                b = value.substr(3, 1);
	                r += r;
	                g += g;
	                b += b;
	            }
	
	        return {
	            Red: parseInt(r, 16),
	            Green: parseInt(g, 16),
	            Blue: parseInt(b, 16),
	            Alpha: 1
	        };
	    },
	
	    combine: function combine(values) {
	        return rgb.combine(values);
	    }
	};

/***/ },
/* 9 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var utils = __webpack_require__(38),
	    rgb = __webpack_require__(7),
	    hsl = __webpack_require__(6),
	    hex = __webpack_require__(8),
	    supported = [rgb, hsl, hex],
	    numSupported = 3,
	    runSupported = function runSupported(method, value) {
	    for (var i = 0; i < numSupported; i++) {
	        if (supported[i].test(value)) {
	            return supported[i][method](value);
	        }
	    }
	};
	
	module.exports = {
	
	    defaultProps: utils.merge(rgb.defaultProps, hsl.defaultProps),
	
	    test: function test(value) {
	        return rgb.test(value) || hex.test(value) || hsl.test(value);
	    },
	
	    split: function split(value) {
	        return runSupported('split', value);
	    },
	
	    combine: function combine(values) {
	        return values.Red !== undefined ? rgb.combine(values) : hsl.combine(values);
	    }
	};

/***/ },
/* 10 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var createDelimited = __webpack_require__(33),
	    pxDefaults = __webpack_require__(5).defaultProps,
	    splitSpaceDelimited = __webpack_require__(39),
	    terms = __webpack_require__(37).positions;
	
	module.exports = {
	
	    defaultProps: pxDefaults,
	
	    /*
	        Split positions in format "X Y Z"
	        
	        @param [string]: Position values
	            "20% 30% 0" -> {20%, 30%, 0}
	            "20% 30%" -> {20%, 30%}
	            "20%" -> {20%, 20%}
	    */
	    split: function split(value) {
	        var positions = splitSpaceDelimited(value),
	            numPositions = positions.length,
	            splitValue = {
	            X: positions[0],
	            Y: numPositions > 1 ? positions[1] : positions[0]
	        };
	
	        if (numPositions > 2) {
	            splitValue.Z = positions[2];
	        }
	
	        return splitValue;
	    },
	
	    combine: function combine(values) {
	        return createDelimited(values, terms, ' ');
	    }
	};

/***/ },
/* 11 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var terms = __webpack_require__(37).dimensions,
	    pxDefaults = __webpack_require__(5).defaultProps,
	    createDelimited = __webpack_require__(33),
	    splitSpaceDelimited = __webpack_require__(39);
	
	module.exports = {
	
	    defaultProps: pxDefaults,
	
	    /*
	        Split dimensions in format "Top Right Bottom Left"
	        
	        @param [string]: Dimension values
	            "20px 0 30px 40px" -> {20px, 0, 30px, 40px}
	            "20px 0 30px" -> {20px, 0, 30px, 0}
	            "20px 0" -> {20px, 0, 20px, 0}
	            "20px" -> {20px, 20px, 20px, 20px}
	        
	        @return [object]: Object with T/R/B/L metrics
	    */
	    split: function split(value) {
	        var dimensions = splitSpaceDelimited(value),
	            numDimensions = dimensions.length,
	            jumpBack = numDimensions !== 1 ? 2 : 1,
	            i = 0,
	            j = 0,
	            splitValue = {};
	
	        for (; i < 4; i++) {
	            splitValue[terms[i]] = dimensions[j];
	
	            // Jump back (to start) counter if we've reached the end of our values
	            j++;
	            j = j === numDimensions ? j - jumpBack : j;
	        }
	
	        return splitValue;
	    },
	
	    combine: function combine(values) {
	        return createDelimited(values, terms, ' ');
	    }
	};

/***/ },
/* 12 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	module.exports = {
	    defaultProps: {
	        init: 1
	    }
	};

/***/ },
/* 13 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var color = __webpack_require__(9),
	    utils = __webpack_require__(38),
	    pxDefaults = __webpack_require__(5).defaultProps,
	    terms = __webpack_require__(37).shadow,
	    splitSpaceDelimited = __webpack_require__(39),
	    createDelimited = __webpack_require__(33),
	    shadowTerms = terms.slice(0, 4);
	
	module.exports = {
	
	    defaultProps: utils.merge(color.defaultProps, {
	        X: pxDefaults,
	        Y: pxDefaults,
	        Radius: pxDefaults,
	        Spread: pxDefaults
	    }),
	
	    /*
	        Split shadow properties "X Y Radius Spread Color"
	        
	        @param [string]: Shadow property
	        @return [object]
	    */
	    split: function split(value) {
	        var bits = splitSpaceDelimited(value),
	            numBits = bits.length,
	            hasReachedColor = false,
	            colorProp = '',
	            thisBit,
	            i = 0,
	            splitValue = {};
	
	        for (; i < numBits; i++) {
	            thisBit = bits[i];
	
	            // If we've reached the color property, append to color string
	            if (hasReachedColor || color.test(thisBit)) {
	                hasReachedColor = true;
	                colorProp += thisBit;
	            } else {
	                splitValue[terms[i]] = thisBit;
	            }
	        }
	
	        return utils.merge(splitValue, color.split(colorProp));
	    },
	
	    combine: function combine(values) {
	        return createDelimited(values, shadowTerms, ' ') + color.combine(values);
	    }
	};

/***/ },
/* 14 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var utils = __webpack_require__(38),
	    each = utils.each,
	    floatRegex = /(-)?(\d[\d\.]*)/g,
	    generateToken = function generateToken(key) {
	    return '${' + key + '}';
	};
	
	module.exports = {
	    test: function test(value) {
	        var matches = value.match(floatRegex);
	        return utils.isArray(matches) && matches.length > 1;
	    },
	
	    template: function template(value) {
	        var counter = 0;
	        return value.replace(floatRegex, function () {
	            return generateToken(counter++);
	        });
	    },
	
	    split: function split(value) {
	        var splitValue = {},
	            matches = value.match(floatRegex),
	            numMatches = matches.length;
	
	        for (var i = 0; i < numMatches; i++) {
	            splitValue[i] = matches[i];
	        }
	
	        return splitValue;
	    },
	
	    combine: function combine(values, template) {
	        var combinedValue = template;
	
	        each(values, function (key, value) {
	            combinedValue = combinedValue.replace(generateToken(key), value);
	        });
	
	        return combinedValue;
	    }
	};

/***/ },
/* 15 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var Role = __webpack_require__(25);
	var each = __webpack_require__(38).each;
	
	var attrRole = new Role({
	    update: function update(state) {
	        var actor = this;
	
	        each(state, function (key, value) {
	            attrRole.set(actor.element, key, value);
	        });
	    },
	
	    get: function get(element, key) {
	        return element.getAttribute(key);
	    },
	
	    set: function set(element, key, value) {
	        element.setAttribute(key, value);
	    }
	});
	
	module.exports = attrRole;

/***/ },
/* 16 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var Role = __webpack_require__(25);
	var build = __webpack_require__(40);
	var each = __webpack_require__(38).each;
	
	var prefixes = ['Webkit', 'Moz', 'O', 'ms', ''];
	var numPrefixes = prefixes.length;
	var propertyNameCache = {};
	var testElement;
	
	/*
	    Test style property for prefixed version
	    
	    @param [string]: Style property
	    @return [string]: Cached property name
	*/
	var testPrefix = function testPrefix(key) {
	    testElement = testElement || document.createElement('div');
	
	    if (propertyNameCache[key] === false) {
	        return false;
	    } else {
	        propertyNameCache[key] = false;
	    }
	
	    for (var i = 0; i < numPrefixes; i++) {
	        var prefix = prefixes[i],
	            prefixed = prefix === '' ? key : prefix + key.charAt(0).toUpperCase() + key.slice(1);
	
	        if (prefixed in testElement.style) {
	            propertyNameCache[key] = prefixed;
	        }
	    }
	
	    return propertyNameCache[key];
	};
	
	var cssRole = new Role({
	    _map: __webpack_require__(41),
	    _typeMap: __webpack_require__(42),
	
	    init: function init() {
	        this._cssCache = {};
	    },
	
	    update: function update(state) {
	        var actor = this;
	
	        each(build(state, actor._cssCache), function (key, value) {
	            cssRole.set(actor.element, key, value);
	        });
	    },
	
	    get: function get(element, key) {
	        key = propertyNameCache[key] || testPrefix(key);
	
	        if (key) {
	            return window.getComputedStyle(element, null)[key];
	        }
	    },
	
	    set: function set(element, key, value) {
	        key = propertyNameCache[key] || testPrefix(key);
	
	        if (key) {
	            element.style[key] = value;
	        }
	    }
	
	});
	
	module.exports = cssRole;

/***/ },
/* 17 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var Role = __webpack_require__(25),
	    attrRole = __webpack_require__(15),
	    build = __webpack_require__(43),
	    each = __webpack_require__(38).each;
	
	module.exports = new Role({
	    _map: __webpack_require__(41),
	    _typeMap: __webpack_require__(44),
	
	    start: function start() {
	        var boundingBox = this.element.getBBox(),
	            values = this.values,
	
	        // TODO: Support px
	        transformOriginX = values.transformOriginX ? values.transformOriginX.current : 50,
	            transformOriginY = values.transformOriginY ? values.transformOriginY.current : 50,
	            origin = {
	            x: boundingBox.width * (transformOriginX / 100) + boundingBox.x,
	            y: boundingBox.height * (transformOriginY / 100) + boundingBox.y
	        };
	
	        this.svgOrigin = origin;
	    },
	
	    update: function update(state) {
	        var actor = this;
	        each(build(state, this.svgOrigin), function (key, value) {
	            attrRole.set(actor.element, key, value);
	        });
	    }
	
	});

/***/ },
/* 18 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var Role = __webpack_require__(25);
	var attrRole = __webpack_require__(15);
	var each = __webpack_require__(38).each;
	
	/*
	    Convert percentage to pixels
	    
	    @param [number]: Percentage of total length
	    @param [number]: Total length
	*/
	var percentToPixels = function percentToPixels(percentage, length) {
	    return parseFloat(percentage) / 100 * length + 'px';
	};
	
	/*
	    Create styles
	    
	    @param [object]: SVG Path properties
	    @param [object]: Length of path
	    @returns [object]: Key/value pairs of valid CSS properties
	*/
	var createStyles = function createStyles(props, length) {
	    var hasDashArray = false,
	        dashArrayStyles = {
	        length: 0,
	        spacing: length + 'px'
	    },
	        styles = {};
	
	    each(props, function (key, value) {
	        key = SVGDrawPath._map[key] || key;
	
	        switch (key) {
	            case 'length':
	            case 'spacing':
	                hasDashArray = true;
	                dashArrayStyles[key] = percentToPixels(value, length);
	                break;
	            case 'offset':
	                styles['stroke-dashoffset'] = percentToPixels(-value, length);
	                break;
	            default:
	                styles[key] = value;
	        }
	    });
	
	    if (hasDashArray) {
	        styles['stroke-dasharray'] = dashArrayStyles.length + ' ' + dashArrayStyles.spacing;
	    }
	
	    return styles;
	};
	
	/*
	    Draw Path role
	*/
	var SVGDrawPath = new Role({
	    _map: __webpack_require__(45),
	
	    _typeMap: {
	        stroke: 'color',
	        d: 'complex'
	    },
	
	    init: function init() {
	        this.pathLength = this.element.getTotalLength();
	    },
	
	    /*
	        Update `path` styles and if `element` is present, set
	        x, y and rotation
	    */
	    update: function update(state) {
	        attrRole.update.call(this, createStyles(state, this.pathLength));
	    }
	});
	
	module.exports = SVGDrawPath;

/***/ },
/* 19 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var each = __webpack_require__(38).each,
	    ValueTypeManager = function ValueTypeManager() {};
	
	ValueTypeManager.prototype = {
	    extend: function extend(name, mod) {
	        var _this = this;
	
	        var multiMods = typeof name == 'object',
	            mods = multiMods ? name : {};
	
	        // If we just have one module, coerce
	        if (!multiMods) {
	            mods[name] = mod;
	        }
	
	        each(mods, function (key, thisMod) {
	            _this[key] = thisMod;
	        });
	    },
	
	    defaultProps: function defaultProps(type, key) {
	        var valueType = this[type],
	            defaultProps = valueType.defaultProps ? valueType.defaultProps[key] || valueType.defaultProps : {};
	
	        return defaultProps;
	    },
	
	    test: function test(value) {
	        var type = false;
	
	        each(this, function (key, mod) {
	            if (mod.test && mod.test(value)) {
	                type = key;
	            }
	        });
	
	        return type;
	    }
	};
	
	module.exports = new ValueTypeManager();

/***/ },
/* 20 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	var Process = __webpack_require__(24),
	    Queue = __webpack_require__(46),
	    utils = __webpack_require__(38),
	    select = __webpack_require__(47),
	    update = __webpack_require__(48),
	    valueOps = __webpack_require__(49),
	
	/*
	    Role imports
	*/
	defaultRole = __webpack_require__(50),
	    cssRole = __webpack_require__(16),
	    svgRole = __webpack_require__(17),
	    drawPathRole = __webpack_require__(18),
	    Action = __webpack_require__(27),
	    each = utils.each;
	
	var Actor = (function () {
	
	    /*
	        @param [object]
	    */
	
	    function Actor() {
	        var opts = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
	
	        _classCallCheck(this, Actor);
	
	        var props = utils.isString(opts) ? { element: opts } : opts;
	
	        this.values = {};
	        this.state = { values: {} };
	        this.queue = new Queue();
	        this.process = new Process(this, update);
	        this.activeActions = {};
	        this.numActive = 0;
	        this.actionCounter = 0;
	        this.activeValues = [];
	        this.activeParents = [];
	        this.isActive = false;
	
	        // Get actual elements if this is a selector
	        if (utils.isString(props.element)) {
	            props.element = select(props.element)[0];
	        }
	
	        this.assignRoles(props.element, props.as, true);
	        this.set(props);
	        this.initRoles();
	    }
	
	    /*
	        Set Actor properties and values
	         @param [object]
	        @returns [Actor]
	    */
	
	    Actor.prototype.set = function set(opts) {
	        var _this = this;
	
	        each(opts, function (key, value) {
	            if (key !== 'values' && key !== 'action') {
	                _this[key] = value;
	            }
	        });
	
	        if (opts && opts.values) {
	            this.values = valueOps.process(this.values, opts.values, opts, 'current', this);
	        }
	
	        // Check all active actions for any that can be removed
	        each(this.activeActions, function (id, action) {
	            var actionIsActive = false;
	
	            each(_this.values, function (key, value) {
	                actionIsActive = value.action === action ? true : actionIsActive;
	            });
	
	            if (!actionIsActive) {
	                _this.unbindAction(id);
	            }
	        });
	
	        return this;
	    };
	
	    /*
	        Bind Action-specific controls to Actor
	         @returns [Controls]
	    */
	
	    Actor.prototype.controls = function controls(action) {
	        var Controls = action.getControls();
	        return new Controls(this, action.getPlayable());
	    };
	
	    /*
	        Start a new Action
	         @param [Action || number]
	        @param [Input || event] (optional)
	        @param [boolean] (optional): defined `true` if we surpress making new queue
	        @returns [Controls]
	    */
	
	    Actor.prototype.start = function start(toSet, input) {
	        var actionExists = utils.isNum(toSet),
	            action = actionExists ? this.getAction(toSet) : toSet.getPlayable(),
	            opts = action.getSet(),
	            surpressQueueClear = arguments[arguments.length - 1] === false;
	
	        opts.action = action;
	
	        this.set(opts);
	
	        if (input) {
	            action.bindInput(input);
	        }
	
	        if (!surpressQueueClear) {
	            this.queue.clear();
	        }
	
	        // Fire all Role onStarts if not already active
	        if (!this.isActive) {
	            var numRoles = this.roles.length;
	            for (var i = 0; i < numRoles; i++) {
	                var role = this.roles[i];
	                if (role.start) {
	                    role.start.call(this, this);
	                }
	            }
	        }
	
	        // Fire new action onStart
	        if (!action.isActive && action.onStart) {
	            action.onStart.call(this, this, action);
	        }
	
	        this.activate();
	
	        if (!actionExists) {
	            var Controls = action.getControls();
	            return new Controls(this, action, true);
	        }
	    };
	
	    /*
	        Pause all active Actions
	         @param [int] (optional)
	        @returns [Actor]
	    */
	
	    Actor.prototype.pause = function pause() {
	        this.isActive = false;
	        each(this.activeActions, function (id, action) {
	            return action.deactivate();
	        });
	        this.process.stop();
	        return this;
	    };
	
	    /*
	        Resume all active Actions
	         @param [int] (optional)
	        @returns [Actor];
	    */
	
	    Actor.prototype.resume = function resume() {
	        this.isActive = true;
	        each(this.activeActions, function (id, action) {
	            return action.activate();
	        });
	        this.process.start();
	        return this;
	    };
	
	    /*
	        Stop all active Actions
	         @param [int] (optional)
	        @returns [Actor]
	    */
	
	    Actor.prototype.stop = function stop() {
	        var _this2 = this;
	
	        this.pause();
	        each(this.activeActions, function (id) {
	            return _this2.unbindAction(id);
	        });
	        return this;
	    };
	
	    /*
	        Toggle all active Actions
	         @param [int] (optional)
	        @returns [Actor]
	    */
	
	    Actor.prototype.toggle = function toggle() {
	        return this.isActive ? this.pause() : this.resume();
	    };
	
	    /*
	        Syncs `element` with current properties
	         @returns [Actor]
	    */
	
	    Actor.prototype.sync = function sync() {
	        this.start(new Action({ values: this.values }));
	        return this;
	    };
	
	    /*
	        Add a new Action to the queue
	    */
	
	    Actor.prototype.then = function then() {
	        this.queue.add.apply(this.queue, arguments);
	        return this;
	    };
	
	    /*
	        Execute next in queue
	    */
	
	    Actor.prototype.next = function next() {
	        var next = this.queue.next();
	
	        if (next) {
	            if (utils.isFunc(next[0])) {
	                next[0]();
	                this.next();
	                // Or this is an action
	            } else {
	                    next.push(false);
	                    this.start.apply(this, next);
	                }
	        } else {
	            this.stop();
	        }
	
	        return this;
	    };
	
	    /*
	        Assign Roles based on element and manually provided props
	         @param [object]: Element
	        @param [Role || array]
	        @param [boolean] (optional)
	    */
	
	    Actor.prototype.assignRoles = function assignRoles(element, manualRoles, surpressInit) {
	        // All Actors get a default Role that handles user callbacks
	        this.roles = [defaultRole];
	
	        // Auto-assign if no manually-set Roles
	        if (!manualRoles && element) {
	            this.autoAssignRoles(element);
	
	            // Or manually set if provided
	        } else if (manualRoles) {
	                if (utils.isArray(manualRoles)) {
	                    this.roles.push.apply(this.roles, manualRoles);
	                } else {
	                    this.roles.push(manualRoles);
	                }
	            }
	
	        if (!surpressInit) {
	            this.initRoles();
	        }
	    };
	
	    /*
	        Automatically assign Roles based on element, designed
	        to be extended
	         @param [object]: Element
	    */
	
	    Actor.prototype.autoAssignRoles = function autoAssignRoles(element) {
	        // Add CSS role if HTMLElement
	        if (element instanceof HTMLElement || element.tagName === 'svg') {
	            this.roles.push(cssRole);
	
	            // Add SVG role if SVG element
	        } else if (element instanceof SVGElement) {
	                this.roles.push(svgRole);
	
	                // Add Draw Path role if path element
	                if (element.tagName === 'path') {
	                    this.roles.push(drawPathRole);
	                }
	            }
	    };
	
	    /*
	        Fire init callbacks
	    */
	
	    Actor.prototype.initRoles = function initRoles() {
	        var _this3 = this;
	
	        // Fire init callback
	        this.roles.forEach(function (role) {
	            if (role.init) {
	                role.init.call(_this3, _this3);
	            }
	        });
	    };
	
	    Actor.prototype.activate = function activate() {
	        if (!this.isActive) {
	            this.isActive = true;
	            this.firstFrame = true;
	            this.process.start();
	        }
	    };
	
	    /*
	        Bind Action and return its table id
	         @param [Action]
	        @returns [int]
	    */
	
	    Actor.prototype.bindAction = function bindAction(action, id) {
	        if (id === undefined) {
	            id = this.actionCounter++;
	        }
	
	        if (!this.hasAction(id)) {
	            this.activeActions[id] = action;
	            this.numActive++;
	        }
	
	        return id;
	    };
	
	    Actor.prototype.unbindAction = function unbindAction(id) {
	        if (this.activeActions.hasOwnProperty(id)) {
	            this.numActive--;
	            delete this.activeActions[id];
	        }
	
	        if (!this.numActive) {
	            this.pause();
	        }
	    };
	
	    Actor.prototype.getAction = function getAction(id) {
	        return this.activeActions[id];
	    };
	
	    Actor.prototype.hasAction = function hasAction(id) {
	        return this.getAction(id) !== undefined;
	    };
	
	    /*
	        Update processing order
	        
	        @param [string]
	        @param [boolean]
	        @param [boolean]
	    */
	
	    Actor.prototype.updateOrder = function updateOrder(key, moveToBack, hasChildren) {
	        var order = !hasChildren ? this.activeValues : this.activeParents,
	            position = order.indexOf(key);
	
	        // If key isn't list or moveToBack is set to true, add key
	        if (position === -1 || moveToBack) {
	            order.push(key);
	
	            // If key already exists, remove
	            if (position > -1) {
	                order.splice(position, 1);
	            }
	        }
	    };
	
	    // [boolean]: Is this Actor active?
	
	    _createClass(Actor, [{
	        key: 'isActive',
	        get: function get() {
	            return this._isActive;
	        },
	
	        // Set hasChanged to true is this is now active
	        set: function set(status) {
	            if (status === true) {
	                this.hasChanged = status;
	            }
	
	            this._isActive = status;
	        }
	    }]);
	
	    return Actor;
	})();
	
	module.exports = Actor;

/***/ },
/* 21 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var Actor = __webpack_require__(20);
	var Tween = __webpack_require__(28);
	var utils = __webpack_require__(38);
	var calcRelative = __webpack_require__(32).relativeValue;
	
	var timeline = new Tween({
	    ease: 'linear',
	    values: {
	        playhead: 0
	    }
	});
	
	function checkActions(_ref, sequence) {
	    var playhead = _ref.playhead;
	
	    var i = sequence.check.length;
	
	    while (i--) {
	        var toCheck = sequence.check[i];
	
	        if (playhead >= toCheck.timestamp) {
	            toCheck.callback();
	            sequence.check.splice(i, 1);
	        }
	    }
	}
	
	function generateCallback(actor, action) {
	    var callback;
	
	    if (actor.each) {
	        callback = function () {
	            actor.each(action);
	        };
	    } else {
	        callback = function () {
	            actor.start(action);
	        };
	    }
	
	    return callback;
	}
	
	var Sequence = (function (_Actor) {
	    _inherits(Sequence, _Actor);
	
	    function Sequence() {
	        _classCallCheck(this, Sequence);
	
	        _Actor.call(this, {
	            check: [],
	            sequence: [],
	            duration: 0,
	            currentTimestamp: 0,
	            prevActionEnd: 0,
	            onUpdate: checkActions
	        });
	    }
	
	    Sequence.prototype['do'] = function _do(actor, action) {
	        var isCallback = utils.isFunc(actor);
	
	        this.sequence.push({
	            timestamp: this.currentTimestamp,
	            callback: isCallback ? actor : generateCallback(actor, action)
	        });
	
	        if (action && action.duration) {
	            this.prevActionEnd = this.currentTimestamp + action.duration;
	        }
	
	        return this;
	    };
	
	    Sequence.prototype.stagger = function stagger(iterator, action, staggerProps) {
	        var numItems = iterator.members.length,
	            interval = utils.isNum(staggerProps) ? staggerProps : staggerProps.interval || 100,
	            duration = action.duration ? action.duration : 0;
	
	        this['do'](iterator, function () {
	            iterator.stagger(action, staggerProps);
	        });
	
	        this.prevActionEnd = this.currentTimestamp + duration + interval * numItems;
	
	        return this;
	    };
	
	    Sequence.prototype.at = function at(timestamp) {
	        if (utils.isString(timestamp)) {
	            timestamp = calcRelative(this.currentTimestamp, timestamp);
	        }
	
	        this.currentTimestamp = timestamp;
	        this.duration = Math.max(this.currentTimestamp, this.duration);
	        return this;
	    };
	
	    Sequence.prototype.then = function then() {
	        var offset = arguments.length <= 0 || arguments[0] === undefined ? "+=0" : arguments[0];
	
	        this.at(calcRelative(this.prevActionEnd, offset));
	        return this;
	    };
	
	    Sequence.prototype.start = function start() {
	        _Actor.prototype.start.call(this, timeline.extend({
	            duration: this.duration,
	            values: {
	                playhead: {
	                    current: 0,
	                    to: this.duration
	                }
	            }
	        }));
	
	        return this;
	    };
	
	    Sequence.prototype.onStart = function onStart() {
	        this.check = this.sequence.slice();
	    };
	
	    Sequence.prototype.clear = function clear() {
	        this.sequence = [];
	        this.duration = this.currentTimestamp = this.prevActionEnd = 0;
	        return this;
	    };
	
	    return Sequence;
	})(Actor);
	
	module.exports = Sequence;

/***/ },
/* 22 */
/***/ function(module, exports, __webpack_require__) {

	/*
	    Input controller
	*/
	"use strict";
	
	var calc = __webpack_require__(32),
	    utils = __webpack_require__(38),
	    History = __webpack_require__(51),
	
	/*
	    Input constructor
	    
	        Syntax
	            newInput(name, value[, poll])
	                @param [string]: Name of to track
	                @param [number]: Initial value
	                @param [function] (optional): Function to poll Input data
	                
	            newInput(props[, poll])
	                @param [object]: Object of values
	                @param [function] (optional): Function to poll Input data
	     @return [Input]
	*/
	Input = function Input() {
	    var pollPos = arguments.length - 1;
	
	    this.current = {};
	    this.offset = {};
	    this.velocity = {};
	    this.history = new History();
	    this.update(arguments[0], arguments[1]);
	
	    if (utils.isFunc(arguments[pollPos])) {
	        this.poll = arguments[pollPos];
	    }
	};
	
	Input.prototype = {
	
	    // [number]: Number of frames of inactivity before velocity is turned to 0
	    maxInactiveFrames: 2,
	
	    // [number]: Number of frames input hasn't been updated
	    inactiveFrames: 0,
	
	    /*
	        Get latest input values
	        
	        @param [string] (optional): Name of specific property to return
	        @return [object || number]: Latest input values or, if specified, single value
	    */
	    get: function get(prop) {
	        var latest = this.history.get(),
	            val = prop !== undefined ? latest[prop] : latest;
	        return val;
	    },
	
	    /*
	        Update the input values
	        
	        Syntax
	            input.update(name, value)
	                @param [string]: Name of to track
	                @param [number]: Initial value
	                
	            input.update(props)
	                @param [object]: Object of values
	                
	        @return [Input]
	    */
	    update: function update(arg0, arg1) {
	        var values = {};
	
	        if (utils.isNum(arg1)) {
	            values[arg0] = arg1;
	        } else {
	            values = arg0;
	        }
	
	        this.history.add(utils.merge(this.current, values));
	
	        return this;
	    },
	
	    /*
	        Check for input movement and update pointer object's properties
	        
	        @param [number]: Timestamp of frame
	        @return [Input]
	    */
	    onFrame: function onFrame(timestamp) {
	        var latest, hasChanged;
	
	        // Check provided timestamp against lastFrame timestamp and return input has already been updated
	        if (timestamp === this.lastFrame) {
	            return;
	        }
	
	        latest = this.poll ? this.poll() : this.history.get();
	        hasChanged = utils.hasChanged(this.current, latest);
	
	        // If input has changed between frames 
	        if (hasChanged) {
	            this.velocity = calc.offset(this.current, latest);
	            this.current = latest;
	            this.inactiveFrames = 0;
	
	            // Or it hasn't moved and our frame limit has been reached
	        } else if (this.inactiveFrames >= this.maxInactiveFrames) {
	                this.velocity = calc.offset(this.current, this.current);
	
	                // Or input hasn't changed
	            } else {
	                    this.inactiveFrames++;
	                }
	
	        this.lastFrame = timestamp;
	
	        return this;
	    }
	};
	
	module.exports = Input;

/***/ },
/* 23 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	var Actor = __webpack_require__(20),
	    Tween = __webpack_require__(28),
	    utils = __webpack_require__(38);
	
	var DEFAULT_STAGGER_EASE = 'linear';
	
	function generateCallback(method) {
	    for (var _len = arguments.length, args = Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
	        args[_key - 1] = arguments[_key];
	    }
	
	    var callback = method;
	
	    if (utils.isString(method)) {
	        callback = function (member) {
	            return member[method].apply(member, args);
	        };
	    } else if (!utils.isFunc(method)) {
	        callback = function (member) {
	            return member.start.apply(member, [method].concat(args));
	        };
	    }
	
	    return callback;
	}
	
	var Iterator = (function () {
	    function Iterator(members) {
	        _classCallCheck(this, Iterator);
	
	        this.clear();
	
	        if (members) {
	            this.add(members);
	        }
	
	        this._stagger = new Actor();
	    }
	
	    Iterator.prototype.add = function add(members) {
	        this.members = this.members.concat(members);
	        return this;
	    };
	
	    Iterator.prototype.clear = function clear() {
	        this.members = [];
	        return this;
	    };
	
	    Iterator.prototype.each = function each(method) {
	        for (var _len2 = arguments.length, args = Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
	            args[_key2 - 1] = arguments[_key2];
	        }
	
	        var callback = generateCallback.apply(undefined, [method].concat(args));
	        this.members.forEach(callback);
	        return this;
	    };
	
	    Iterator.prototype.eachIntoNew = function eachIntoNew(method) {
	        for (var _len3 = arguments.length, args = Array(_len3 > 1 ? _len3 - 1 : 0), _key3 = 1; _key3 < _len3; _key3++) {
	            args[_key3 - 1] = arguments[_key3];
	        }
	
	        var callback = generateCallback.apply(undefined, [method].concat(args)),
	            newIterator = new Iterator();
	
	        this.members.forEach(function (member) {
	            return newIterator.add(callback(member));
	        });
	
	        return newIterator;
	    };
	
	    Iterator.prototype.stagger = function stagger(method, props) {
	        for (var _len4 = arguments.length, args = Array(_len4 > 2 ? _len4 - 2 : 0), _key4 = 2; _key4 < _len4; _key4++) {
	            args[_key4 - 2] = arguments[_key4];
	        }
	
	        var tempMembers = utils.copyArray(this.members),
	            numMembers = tempMembers.length,
	            propsIsInterval = utils.isNum(props),
	            interval = propsIsInterval ? props : props.interval || 100,
	            staggerProps = {},
	            i = -1,
	            callback = generateCallback.apply(undefined, [method].concat(args));
	
	        staggerProps.values = {
	            i: {
	                current: -0.6,
	                duration: interval * numMembers,
	                ease: propsIsInterval ? DEFAULT_STAGGER_EASE : props.ease || DEFAULT_STAGGER_EASE,
	                round: true,
	                to: numMembers - 0.6
	            }
	        };
	
	        staggerProps.onComplete = propsIsInterval ? undefined : props.onComplete;
	
	        staggerProps.onUpdate = function (output) {
	            var newIndex = output.i,
	                gapIndex = i + 1;
	
	            // If our new index is only one more than the previous index, fire immedietly
	            if (newIndex === i + 1) {
	                callback(tempMembers[gapIndex], gapIndex);
	
	                // Or loop through the distance to fire all indecies. Increase delay.
	            } else {
	                    for (; gapIndex <= newIndex; gapIndex++) {
	                        callback(tempMembers[gapIndex], gapIndex);
	                    }
	                }
	
	            i = newIndex;
	        };
	
	        this._stagger.start(new Tween(staggerProps));
	
	        return this;
	    };
	
	    /*
	        Array manipulation
	    */
	
	    Iterator.prototype.reverse = function reverse() {
	        this.members.reverse();
	        return this;
	    };
	
	    return Iterator;
	})();
	
	module.exports = Iterator;

/***/ },
/* 24 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var manager = __webpack_require__(57),
	
	/*
	    Process constructor
	    
	    Syntax
	        var process = new Process(scope, callback);
	        var process = new Process(callback);
	*/
	Process = function Process(scope, callback) {
	    var hasScope = callback !== undefined;
	
	    this.callback = hasScope ? callback : scope;
	    this.scope = hasScope ? scope : this;
	    this.id = manager.register();
	
	    // [boolean]: Is this process currently active?
	    this.isActive = false;
	};
	
	Process.prototype = {
	    /*
	        Fire callback
	        
	        @param [timestamp]: Timestamp of currently-executed frame
	        @param [number]: Time since last frame
	    */
	    fire: function fire(timestamp, elapsed) {
	        this.callback.call(this.scope, timestamp, elapsed);
	
	        // If we're running at an interval, deactivate again
	        if (this.isInterval) {
	            this.deactivate();
	        }
	
	        return this;
	    },
	
	    /*
	        Start process
	        
	        @param [int]: Duration of process in ms, 0 if indefinite
	        @return [this]
	    */
	    start: function start(duration) {
	        var self = this;
	
	        this.reset();
	        this.activate();
	
	        if (duration) {
	            this.stopTimer = setTimeout(function () {
	                self.stop();
	            }, duration);
	
	            this.isStopTimerActive = true;
	        }
	
	        return this;
	    },
	
	    /*
	        Stop process
	        
	        @return [this]
	    */
	    stop: function stop() {
	        this.reset();
	        this.deactivate();
	
	        return this;
	    },
	
	    /*
	        Activate process
	        
	        @return [this]
	    */
	    activate: function activate() {
	        this.isActive = true;
	        manager.activate(this, this.id);
	
	        return this;
	    },
	
	    /*
	        Deactivate process
	        
	        @return [this]
	    */
	    deactivate: function deactivate() {
	        this.isActive = false;
	        manager.deactivate(this.id);
	
	        return this;
	    },
	
	    /*
	        Fire process every x ms
	        
	        @param [int]: Number of ms to wait between refiring process.
	        @return [this]
	    */
	    every: function every(interval) {
	        var self = this;
	
	        this.reset();
	
	        this.isInterval = true;
	
	        this.intervalTimer = setInterval(function () {
	            self.activate();
	        }, interval);
	
	        this.isIntervalTimeActive = true;
	
	        return this;
	    },
	
	    /*
	        Clear all timers
	        
	        @param 
	    */
	    reset: function reset() {
	        this.isInterval = false;
	
	        if (this.isStopTimerActive) {
	            clearTimeout(this.stopTimer);
	        }
	
	        if (this.isIntervalTimeActive) {
	            clearInterval(this.intervalTimer);
	        }
	
	        return this;
	    }
	};
	
	module.exports = Process;

/***/ },
/* 25 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var utils = __webpack_require__(38);
	var each = utils.each;
	
	/*
	    Role class constructor
	
	    @param [object]: Optional methods and props to add:
	        name [string]:      Name of generated getter/setter method on Actor
	        _map [object]:      Map Actor values to these values for this Role
	        _typeMap [object]:  Map values to value types
	        init [function]:    Callback to run when this Role is added to an Actor
	        start [function]:   Callback to run when host Actor starts an action
	        complete [function]: Callback to run when action completes
	        frame [function]:   Callback to fire once per frame
	        update [function]:  Callback to fire when values change
	        get [function]:     Read value from actual element
	        set [function]:     Set value on actual element
	*/
	var Role = function Role(methods) {
	    var role = function role(element, opts, prop) {
	        var typeOfOpts = typeof opts;
	
	        // Set single, if this is a string and we have a property
	        if (typeOfOpts === 'string' && prop) {
	            role.set(element, opts, prop);
	
	            // Set multi, if this is an object
	        } else if (typeOfOpts === 'object') {
	                each(opts, function (key, value) {
	                    role.set(element, key, value);
	                });
	
	                // Or this is a get if we have a string and no props
	            } else {
	                    return role.get(element, opts);
	                }
	
	        return role;
	    };
	
	    role._map = {};
	
	    each(methods, function (name, method) {
	        role[name] = !utils.isObj(method) ? method : utils.copy(method);
	    });
	
	    /*
	        Map value keys or generate new Role with updated map
	         Getter:
	            @param [string]: Key to map
	            @return [string]: Mapped key, or key if no mapped key found
	         Setter: 
	            @param [object]: Map of Actor keys -> Role keys
	            @return [Role]: New Role with unique map
	    */
	    role.map = function (values) {
	        // If this is a string, get mapped value
	        // Otherwise this is a map, duplicated role with updated map
	        return utils.isString(values) ? this._map[values] || values : createRole(this, values);
	    };
	
	    return role;
	};
	
	/*
	    Create a new role
	
	    @param [object]: Optional methods and props to add
	    @param [valuesToMap]: Override existing map with these values
	    @return [Role]: New Role
	*/
	var createRole = function createRole(methods, values) {
	    var newRole = new Role(methods);
	
	    each(values, function (key, value) {
	        newRole._map[key] = value;
	    });
	
	    return newRole;
	};
	
	module.exports = Role;

/***/ },
/* 26 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var Bezier = __webpack_require__(58),
	
	/*
	    Mirror easing
	    
	    Mirrors the provided easing function, used here for mirroring an
	    easeIn into an easeInOut
	    
	    @param [number]: Progress, from 0 - 1, of current shift
	    @param [function]: The easing function to mirror
	    @returns [number]: The easing-adjusted delta
	*/
	mirrorEasing = function mirrorEasing(progress, method) {
	    return progress <= 0.5 ? method(2 * progress) / 2 : (2 - method(2 * (1 - progress))) / 2;
	},
	
	/*
	    Reverse easing
	    
	    Reverses the output of the provided easing function, used for flipping easeIn
	    curve to an easeOut.
	    
	    @param [number]: Progress, from 0 - 1, of current shift
	    @param [function]: The easing function to reverse
	    @returns [number]: The easing-adjusted delta
	*/
	reverseEasing = function reverseEasing(progress, method) {
	    return 1 - method(1 - progress);
	};
	
	/*
	    Easing class
	
	    If provided easing function, returns easing function with 
	    in/out/inOut variations
	
	    If provided four arguments, returns new Bezier class instead.
	*/
	var Easing = function Easing(x1, y1, x2, y2) {
	    var method = x1,
	        easingFunction;
	
	    // If this is a bezier curve, return a bezier function
	    if (arguments.length > 1) {
	        easingFunction = new Bezier(x1, y1, x2, y2);
	    } else {
	        easingFunction = function (progress) {
	            return method(progress);
	        };
	
	        easingFunction['in'] = function (progress) {
	            return method(progress);
	        };
	
	        easingFunction.out = function (progress) {
	            return reverseEasing(progress, method);
	        };
	
	        easingFunction.inOut = function (progress) {
	            return mirrorEasing(progress, method);
	        };
	    }
	
	    return easingFunction;
	};
	
	module.exports = Easing;

/***/ },
/* 27 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	var calc = __webpack_require__(32),
	    utils = __webpack_require__(38),
	    each = utils.each,
	    Controls = __webpack_require__(52);
	
	var DEFAULT_PROP = 'current';
	var PRIVATE = ['onStart', 'onFrame', 'onUpdate', 'onComplete'];
	
	var Action = (function () {
	    function Action(props) {
	        _classCallCheck(this, Action);
	
	        var action = this;
	
	        utils.each(this.getDefaultProps(), function (key, value) {
	            action[key] = value;
	        });
	
	        this.values = {};
	        this.set(props, this.getDefaultValueProp());
	    }
	
	    Action.prototype.set = function set() {
	        var _this = this;
	
	        var props = arguments.length <= 0 || arguments[0] === undefined ? {} : arguments[0];
	        var defaultProp = arguments.length <= 1 || arguments[1] === undefined ? DEFAULT_PROP : arguments[1];
	
	        each(props, function (key, prop) {
	            if (key !== 'values') {
	                _this[key] = prop;
	            }
	        });
	
	        // Merge values
	        if (props.values) {
	            (function () {
	                var currentValues = _this.values,
	                    values = props.values;
	
	                each(values, function (key, value) {
	                    var existingValue = currentValues[key],
	                        newValue = {};
	
	                    if (utils.isObj(value)) {
	                        newValue = value;
	                    } else {
	                        newValue[defaultProp] = value;
	                    }
	
	                    currentValues[key] = existingValue ? utils.merge(existingValue, newValue) : newValue;
	                });
	            })();
	        }
	
	        return this;
	    };
	
	    Action.prototype.process = function process(actor, value) {
	        return value.current;
	    };
	
	    /*
	         Has Action ended?
	         
	         Returns true to end immedietly
	         
	         @return [boolean]: true
	     */
	
	    Action.prototype.hasEnded = function hasEnded() {
	        return true;
	    };
	
	    Action.prototype.limit = function limit(output, value) {
	        var restricted = calc.restricted(output, value.min, value.max),
	            escapeAmp = value.escapeAmp !== undefined ? value.escapeAmp : 0;
	        return restricted + (output - restricted) * escapeAmp;
	    };
	
	    Action.prototype.getControls = function getControls() {
	        return Controls;
	    };
	
	    Action.prototype.getDefaultProps = function getDefaultProps() {
	        return {};
	    };
	
	    Action.prototype.getDefaultValue = function getDefaultValue() {
	        return {};
	    };
	
	    Action.prototype.getDefaultValueProp = function getDefaultValueProp() {
	        return DEFAULT_PROP;
	    };
	
	    Action.prototype.getSet = function getSet() {
	        var _this2 = this;
	
	        var set = { values: this.values };
	
	        each(this, function (key, prop) {
	            if (_this2.hasOwnProperty(key) && PRIVATE.indexOf(key) === -1) {
	                set[key] = prop;
	            }
	        });
	
	        return set;
	    };
	
	    Action.prototype.extend = function extend(props) {
	        return new this.constructor(utils.merge(this, props), this.getDefaultValueProp());
	    };
	
	    Action.prototype.getPlayable = function getPlayable() {
	        return this.extend();
	    };
	
	    Action.prototype.activate = function activate() {
	        this.isActive = true;
	        return this;
	    };
	
	    Action.prototype.deactivate = function deactivate() {
	        this.isActive = false;
	        return this;
	    };
	
	    return Action;
	})();
	
	module.exports = Action;

/***/ },
/* 28 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var Action = __webpack_require__(27),
	    calc = __webpack_require__(32),
	    utils = __webpack_require__(38),
	    each = utils.each,
	    presetEasing = __webpack_require__(53),
	    valueOps = __webpack_require__(49),
	    TweenControls = __webpack_require__(54),
	    nextSteps = {
	    loop: 'restart',
	    yoyo: 'reverse',
	    flip: 'flipValues'
	},
	
	/*
	    Ease value within ranged parameters
	    
	    @param [number]: Progress between 0 and 1
	    @param [number]: Value of 0 progress
	    @param [number]: Value of 1 progress
	    @param [string || function]: Name of preset easing
	        to use or generated easing function
	    @return [number]: Value of eased progress in range
	*/
	ease = function ease(progress, from, to, _ease) {
	    var progressLimited = calc.restricted(progress, 0, 1),
	        easingFunction = utils.isString(_ease) ? presetEasing[_ease] : _ease;
	
	    return calc.valueEased(progressLimited, from, to, easingFunction);
	};
	
	var COUNT = 'count';
	
	var Tween = (function (_Action) {
	    _inherits(Tween, _Action);
	
	    function Tween() {
	        _classCallCheck(this, Tween);
	
	        _Action.apply(this, arguments);
	    }
	
	    Tween.prototype.getControls = function getControls() {
	        return TweenControls;
	    };
	
	    Tween.prototype.getDefaultProps = function getDefaultProps() {
	        return {
	            delay: 0,
	            dilate: 1,
	            duration: 300,
	            loop: false,
	            yoyo: false,
	            flip: false,
	            playDirection: 1,
	            ended: true,
	            elapsed: 0
	        };
	    };
	
	    Tween.prototype.getDefaultValue = function getDefaultValue() {
	        return {
	            delay: 0,
	            duration: 300,
	            ease: 'easeOut',
	            stagger: 0,
	            steps: 0,
	            to: 0,
	            round: false
	        };
	    };
	
	    Tween.prototype.getDefaultValueProp = function getDefaultValueProp() {
	        return 'to';
	    };
	
	    /*
	        Update Action elapsed time
	        
	        @param [object]: Action properties
	        @param [number]: Timestamp of current frame
	    */
	
	    Tween.prototype.onFrameStart = function onFrameStart(actor, frameDuration) {
	        this.elapsed = this.elapsed || 0;
	
	        if (frameDuration) {
	            this.elapsed += frameDuration * actor.dilate * this.playDirection;
	            this.ended = true;
	        }
	    };
	
	    /*
	        Calculate progress of value based on time elapsed,
	        value delay/duration/stagger properties
	         @param [Actor]
	        @param [object]: Value state and properties
	        @return [number]: Calculated value
	    */
	
	    Tween.prototype.process = function process(actor, value) {
	        var target = value.to,
	            progressTarget = this.playDirection === 1 ? 1 : 0,
	            newValue = value.current,
	            progress;
	
	        // If this value has a to property, otherwise we just return current value
	        if (target !== undefined) {
	            progress = calc.restricted(calc.progress(this.elapsed - value.delay, value.duration) - value.stagger, 0, 1);
	
	            // Mark Action as NOT ended if still in progress
	            if (progress !== progressTarget) {
	                this.ended = false;
	            }
	
	            // Step progress if we're stepping
	            if (value.steps) {
	                progress = utils.stepProgress(progress, value.steps);
	            }
	
	            // Ease value
	            newValue = ease(progress, value.origin, target, value.ease);
	        }
	
	        return newValue;
	    };
	
	    /*
	        If this tween has ended, check if we loop/yoyo/flip
	        
	        @return [boolean]: Has this tween really really ended?
	    */
	
	    Tween.prototype.hasEnded = function hasEnded(actor) {
	        var _this = this;
	
	        if (this.ended) {
	            each(nextSteps, function (name, methodName) {
	                if (_this.checkNextStep(actor, name, _this[methodName])) {
	                    _this.ended = false;
	                    actor.hasChanged = true;
	                    return false;
	                }
	            });
	        }
	
	        return this.ended;
	    };
	
	    Tween.prototype.checkNextStep = function checkNextStep(actor, name, method) {
	        var stepTaken = false,
	            step = this[name],
	            count = this[name + COUNT] || 0,
	            forever = step === true;
	
	        if (forever || utils.isNum(step)) {
	            ++count;
	            this[name + COUNT] = count;
	
	            if (forever || count <= step) {
	                method.call(this, actor);
	                stepTaken = true;
	            }
	        }
	
	        return stepTaken;
	    };
	
	    Tween.prototype.flipValues = function flipValues(actor) {
	        var actorValues = actor.values;
	        this.elapsed = this.duration - this.elapsed;
	
	        each(this.values, function (key) {
	            var value = actorValues[key];
	
	            if (value.children) {
	                each(value.children, function (childKey) {
	                    valueOps.flip(actorValues[key + childKey]);
	                });
	            }
	
	            valueOps.flip(value);
	        });
	    };
	
	    Tween.prototype.reverse = function reverse() {
	        this.playDirection *= -1;
	    };
	
	    Tween.prototype.restart = function restart() {
	        this.elapsed = this.playDirection === 1 ? 0 : this.duration;
	        this.started = utils.currentTime();
	    };
	
	    return Tween;
	})(Action);
	
	module.exports = Tween;

/***/ },
/* 29 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var Action = __webpack_require__(27),
	    calc = __webpack_require__(32),
	    utils = __webpack_require__(38),
	    simulations = __webpack_require__(55);
	
	var DEFAULT_PROP = 'velocity';
	
	var Simulate = (function (_Action) {
	    _inherits(Simulate, _Action);
	
	    function Simulate() {
	        _classCallCheck(this, Simulate);
	
	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	            args[_key] = arguments[_key];
	        }
	
	        _Action.call.apply(_Action, [this].concat(args));
	        this.calculatesVelocity = true;
	        this.inactiveFrames = 0;
	    }
	
	    Simulate.prototype.getDefaultProps = function getDefaultProps() {
	        return {
	            maxInactiveFrames: 3
	        };
	    };
	
	    Simulate.prototype.getDefaultValue = function getDefaultValue() {
	        return {
	            // [string]: Simulation to .run
	            simulate: DEFAULT_PROP,
	
	            // [number]: Deceleration to apply to value, in units per second
	            deceleration: 0,
	
	            // [number]: Acceleration to apply to value, in units per second
	            acceleration: 0,
	
	            // [number]: Factor to multiply velocity by on bounce
	            bounce: 0,
	
	            // [number]: Spring strength during 'string'
	            spring: 80,
	
	            // [number]: Timeconstant of glide
	            timeConstant: 395,
	
	            // [number]: Stop simulation under this speed
	            stopSpeed: 5,
	
	            // [boolean]: Capture with spring physics on limit breach
	            capture: false,
	
	            // [number]: Friction to apply per frame
	            friction: 0,
	
	            to: 0,
	            round: false
	        };
	    };
	
	    Simulate.prototype.getDefaultValueProp = function getDefaultValueProp() {
	        return DEFAULT_PROP;
	    };
	
	    Simulate.prototype.onStart = function onStart() {
	        this.started = utils.currentTime();
	    };
	
	    /*
	        Simulate the Value's per-frame movement
	        
	        @param [Actor]
	        @param [Value]: Current value
	        @param [string]: Key of current value
	        @param [number]: Duration of frame in ms
	        @return [number]: Calculated value
	    */
	
	    Simulate.prototype.process = function process(actor, value, key, timeSinceLastFrame) {
	        var simulate = value.simulate,
	            simulation = utils.isString(simulate) ? simulations[simulate] : simulate,
	            newVelocity = simulation ? simulation(value, timeSinceLastFrame, this.started) : 0;
	
	        value.velocity = Math.abs(newVelocity) >= value.stopSpeed ? newVelocity : 0;
	        return value.current + calc.speedPerFrame(value.velocity, timeSinceLastFrame);
	    };
	
	    /*
	        Has this action ended?
	        
	        Use a framecounter to see if Action has changed in the last x frames
	        and declare ended if not
	        
	        @param [Actor]
	        @param [boolean]: Has Action changed?
	        @return [boolean]: Has Action ended?
	    */
	
	    Simulate.prototype.hasEnded = function hasEnded(actor, hasChanged) {
	        this.inactiveFrames = hasChanged ? 0 : this.inactiveFrames + 1;
	        return this.inactiveFrames > actor.maxInactiveFrames;
	    };
	
	    /*
	        Limit output to value range, if any
	        
	        If velocity is at or more than range, and value has a bounce property,
	        run the bounce simulation
	        
	        @param [number]: Calculated output
	        @param [Value]: Current Value
	        @return [number]: Limit-adjusted output
	    */
	
	    Simulate.prototype.limit = function limit(output, value) {
	        var isOutsideMax = output >= value.max,
	            isOutsideMin = output <= value.min,
	            isOutsideRange = isOutsideMax || isOutsideMin;
	
	        if (isOutsideRange) {
	            output = calc.restricted(output, value.min, value.max);
	
	            if (value.bounce) {
	                value.velocity = simulations.bounce(value);
	            } else if (value.capture) {
	                simulations.capture(value, isOutsideMax ? value.max : value.min);
	            }
	        }
	
	        return output;
	    };
	
	    return Simulate;
	})(Action);
	
	module.exports = Simulate;

/***/ },
/* 30 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var Action = __webpack_require__(27),
	    Pointer = __webpack_require__(56),
	    calc = __webpack_require__(32);
	
	function smooth(newValue, oldValue, duration, smoothing) {
	    return oldValue + duration * (newValue - oldValue) / smoothing;
	}
	
	var Track = (function (_Action) {
	    _inherits(Track, _Action);
	
	    function Track() {
	        _classCallCheck(this, Track);
	
	        _Action.apply(this, arguments);
	    }
	
	    /*
	        Update input offset
	    */
	
	    Track.prototype.onFrameStart = function onFrameStart(actor, frameDuration, framestamp) {
	        actor.state.input = this.input.onFrame(framestamp);
	        this.inputOffset = calc.offset(this.inputOrigin, this.input.current);
	        this.frameDuration = frameDuration;
	    };
	
	    /*
	        Move Value relative to Input movement
	        
	        @param [Value]: Current value
	        @param [string]: Key of current value
	        @return [number]: Calculated value
	    */
	
	    Track.prototype.process = function process(actor, value, key) {
	        var newValue = value.current,
	            unmapped = value.unmapped !== undefined ? value.unmapped : value.current;
	
	        if (this.inputOffset.hasOwnProperty(key)) {
	            newValue = value.direct ? this.input.current[key] : value.origin + this.inputOffset[key] * value.amp;
	            newValue = value.smooth ? smooth(newValue, unmapped, this.frameDuration, value.smooth) : newValue;
	        }
	
	        return newValue;
	    };
	
	    /*
	        Has this Action ended? 
	        
	        @return [boolean]: False to make user manually finish .track()
	    */
	
	    Track.prototype.hasEnded = function hasEnded() {
	        return false;
	    };
	
	    Track.prototype.deactivate = function deactivate() {
	        _Action.prototype.deactivate.call(this);
	
	        if (this.input && this.input.stop) {
	            this.input.stop();
	        }
	
	        return this;
	    };
	
	    Track.prototype.bindInput = function bindInput(input) {
	        this.input = !input.current ? new Pointer(input) : input;
	        this.inputOrigin = this.input.get();
	    };
	
	    Track.prototype.getDefaultValue = function getDefaultValue() {
	        return {
	            amp: 1,
	            direct: false,
	            smooth: 0
	        };
	    };
	
	    return Track;
	})(Action);
	
	module.exports = Track;

/***/ },
/* 31 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var Actor = __webpack_require__(20),
	    Iterator = __webpack_require__(23),
	    selectDom = __webpack_require__(47);
	
	var SAVE_PROP = '__pm_actor_';
	
	module.exports = function (selector) {
	    var opts = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];
	
	    var dom = selectDom(selector),
	        actors = [];
	
	    dom.forEach(function (element) {
	        var actor = element[SAVE_PROP];
	
	        if (!actor) {
	            opts.element = element;
	            actor = element[SAVE_PROP] = new Actor(opts);
	        }
	
	        actors.push(actor);
	    });
	
	    return actors.length > 1 ? new Iterator(actors) : actors[0];
	};

/***/ },
/* 32 */
/***/ function(module, exports, __webpack_require__) {

	/*
	    Calculators
	    ----------------------------------------
	    
	    Simple I/O snippets
	*/
	"use strict";
	
	var utils = __webpack_require__(38),
	    calc = {
	
	    /*
	        Angle between points
	        
	        Translates the hypothetical line so that the 'from' coordinates
	        are at 0,0, then return the angle using .angleFromCenter()
	        
	        @param [object]: X and Y coordinates of from point
	        @param [object]: X and Y cordinates of to point
	        @return [radian]: Angle between the two points in radians
	    */
	    angle: function angle(pointA, pointB) {
	        var from = pointB ? pointA : { x: 0, y: 0 },
	            to = pointB || pointA,
	            point = {
	            x: to.x - from.x,
	            y: to.y - from.y
	        };
	
	        return this.angleFromCenter(point.x, point.y);
	    },
	
	    /*
	        Angle from center
	        
	        Returns the current angle, in radians, of a defined point
	        from a center (assumed 0,0)
	        
	        @param [number]: X coordinate of second point
	        @param [number]: Y coordinate of second point
	        @return [radian]: Angle between 0, 0 and point in radians
	    */
	    angleFromCenter: function angleFromCenter(x, y) {
	        return this.radiansToDegrees(Math.atan2(y, x));
	    },
	
	    /*
	        Convert degrees to radians
	        
	        @param [number]: Value in degrees
	        @return [number]: Value in radians
	    */
	    degreesToRadians: function degreesToRadians(degrees) {
	        return degrees * Math.PI / 180;
	    },
	
	    /*
	        Dilate
	        
	        Change the progression between a and b according to dilation.
	        
	        So dilation = 0.5 would change
	        
	        a --------- b
	        
	        to
	        
	        a ---- b
	        
	        @param [number]: Previous value
	        @param [number]: Current value
	        @param [number]: Dilate progress by x
	        @return [number]: Previous value plus the dilated difference
	    */
	    dilate: function dilate(a, b, dilation) {
	        return a + (b - a) * dilation;
	    },
	
	    /*
	        Distance
	        
	        Returns the distance between (0,0) and pointA, unless pointB
	        is provided, then we return the difference between the two.
	        
	        @param [object/number]: x and y or just x of point A
	        @param [object/number]: (optional): x and y or just x of point B
	        @return [number]: The distance between the two points
	    */
	    distance: function distance(pointA, pointB) {
	        return typeof pointA === "number" ? this.distance1D(pointA, pointB) : this.distance2D(pointA, pointB);
	    },
	
	    /*
	        Distance 1D
	        
	        Returns the distance between point A and point B
	        
	        @param [number]: Point A
	        @param [number]: (optional): Point B
	        @return [number]: The distance between the two points
	    */
	    distance1D: function distance1D(pointA, pointB) {
	        var bIsNum = typeof pointB === 'number',
	            from = bIsNum ? pointA : 0,
	            to = bIsNum ? pointB : pointA;
	
	        return absolute(to - from);
	    },
	
	    /*
	        Distance 2D
	        
	        Returns the distance between (0,0) and point A, unless point B
	        is provided, then we return the difference between the two.
	        
	        @param [object]: x and y of point A
	        @param [object]: (optional): x and y of point B
	        @return [number]: The distance between the two points
	    */
	    distance2D: function distance2D(pointA, pointB) {
	        var bIsObj = typeof pointB === "object",
	            from = bIsObj ? pointA : { x: 0, y: 0 },
	            to = bIsObj ? pointB : pointA,
	            point = {
	            x: absolute(to.x - from.x),
	            y: absolute(to.y - from.y)
	        };
	
	        return this.hypotenuse(point.x, point.y);
	    },
	
	    /*
	        Hypotenuse
	        
	        Returns the hypotenuse, side C, given the lengths of sides A and B.
	        
	        @param [number]: Length of A
	        @param [number]: Length of B
	        @return [number]: Length of C
	    */
	    hypotenuse: function hypotenuse(a, b) {
	        var a2 = a * a,
	            b2 = b * b,
	            c2 = a2 + b2;
	
	        return Math.sqrt(c2);
	    },
	
	    /*
	        Offset between two inputs
	        
	        Calculate the difference between two different inputs
	        
	        @param [Point]: First input
	        @param [Point]: Second input
	        @return [Offset]: Distance metrics between two points
	    */
	    offset: function offset(a, b) {
	        var offset = {};
	
	        for (var key in b) {
	            if (b.hasOwnProperty(key)) {
	                if (a.hasOwnProperty(key)) {
	                    offset[key] = b[key] - a[key];
	                } else {
	                    offset[key] = 0;
	                }
	            }
	        }
	
	        if (isNum(offset.x) && isNum(offset.y)) {
	            offset.angle = this.angle(a, b);
	            offset.distance = this.distance2D(a, b);
	        }
	
	        return offset;
	    },
	
	    /*
	        Point from angle and distance
	        
	        @param [object]: 2D point of origin
	        @param [number]: Angle from origin
	        @param [number]: Distance from origin
	        @return [object]: Calculated 2D point
	    */
	    pointFromAngleAndDistance: function pointFromAngleAndDistance(origin, angle, distance) {
	        var point = {};
	
	        point.x = distance * Math.cos(angle) + origin.x;
	        point.y = distance * Math.sin(angle) + origin.y;
	
	        return point;
	    },
	
	    /*
	        Progress within given range
	        
	        Given a lower limit and an upper limit, we return the progress
	        (expressed as a number 0-1) represented by the given value, and
	        limit that progress to within 0-1.
	        
	        @param [number]: Value to find progress within given range
	        @param [number]: Lower limit if full range given, upper if not
	        @param [number] (optional): Upper limit of range
	        @return [number]: Progress of value within range as expressed 0-1
	    */
	    progress: function progress(value, limitA, limitB) {
	        var bIsNum = typeof limitB === 'number',
	            from = bIsNum ? limitA : 0,
	            to = bIsNum ? limitB : limitA,
	            range = to - from,
	            progress = (value - from) / range;
	
	        return progress;
	    },
	
	    /*
	        Convert radians to degrees
	        
	        @param [number]: Value in radians
	        @return [number]: Value in degrees
	    */
	    radiansToDegrees: function radiansToDegrees(radians) {
	        return radians * 180 / Math.PI;
	    },
	
	    /*
	        Return random number between range
	        
	        @param [number] (optional): Output minimum
	        @param [number] (optional): Output maximum
	        @return [number]: Random number within range, or 0 and 1 if none provided
	    */
	    random: function random() {
	        var min = arguments.length <= 0 || arguments[0] === undefined ? 0 : arguments[0];
	        var max = arguments.length <= 1 || arguments[1] === undefined ? 1 : arguments[1];
	
	        return Math.random() * (max - min) + min;
	    },
	
	    /*
	        Calculate relative value
	        
	        Takes the operator and value from a string, ie "+=5", and applies
	        to the current value to resolve a new target.
	        
	        @param [number]: Current value
	        @param [string]: Relative value
	        @return [number]: New value
	    */
	    relativeValue: function relativeValue(current, rel) {
	        var newValue = current;
	        var equation = rel.split('=');
	        var operator = equation[0];
	
	        var _utils$splitValUnit = utils.splitValUnit(equation[1]);
	
	        var unit = _utils$splitValUnit.unit;
	        var value = _utils$splitValUnit.value;
	
	        value = parseFloat(value);
	
	        switch (operator) {
	            case '+':
	                newValue += value;
	                break;
	            case '-':
	                newValue -= value;
	                break;
	            case '*':
	                newValue *= value;
	                break;
	            case '/':
	                newValue /= value;
	                break;
	        }
	
	        if (unit) {
	            newValue += unit;
	        }
	
	        return newValue;
	    },
	
	    /*
	        Restrict value to range
	        
	        Return value within the range of lowerLimit and upperLimit
	        
	        @param [number]: Value to keep within range
	        @param [number]: Lower limit of range
	        @param [number]: Upper limit of range
	        @return [number]: Value as limited within given range
	    */
	    restricted: function restricted(value, min, max) {
	        var restricted = min !== undefined ? Math.max(value, min) : value;
	        restricted = max !== undefined ? Math.min(restricted, max) : restricted;
	
	        return restricted;
	    },
	
	    /*
	        Convert x per second to per frame velocity based on fps
	        
	        @param [number]: Unit per second
	        @param [number]: Frame duration in ms
	    */
	    speedPerFrame: function speedPerFrame(xps, frameDuration) {
	        return isNum(xps) ? xps / (1000 / frameDuration) : 0;
	    },
	
	    /*
	        Convert velocity into velicity per second
	        
	        @param [number]: Unit per frame
	        @param [number]: Frame duration in ms
	    */
	    speedPerSecond: function speedPerSecond(velocity, frameDuration) {
	        return velocity * (1000 / frameDuration);
	    },
	
	    /*
	        Value in range from progress
	        
	        Given a lower limit and an upper limit, we return the value within
	        that range as expressed by progress (a number from 0-1)
	        
	        @param [number]: The progress between lower and upper limits expressed 0-1
	        @param [number]: Lower limit of range, or upper if limit2 not provided
	        @param [number] (optional): Upper limit of range
	        @return [number]: Value as calculated from progress within range (not limited within range)
	    */
	    value: function value(progress, limitA, limitB) {
	        var bIsNum = typeof limitB === 'number',
	            from = bIsNum ? limitA : 0,
	            to = bIsNum ? limitB : limitA;
	
	        return -progress * from + progress * to + from;
	    },
	
	    /*
	        Eased value in range from progress
	        
	        Given a lower limit and an upper limit, we return the value within
	        that range as expressed by progress (a number from 0-1)
	        
	        @param [number]: The progress between lower and upper limits expressed 0-1
	        @param [number]: Lower limit of range, or upper if limit2 not provided
	        @param [number]: Upper limit of range
	        @param [function]: Easing to apply to value
	        @return [number]: Value as calculated from progress within range (not limited within range)
	    */
	    valueEased: function valueEased(progress, from, to, easing) {
	        var easedProgress = easing(progress);
	
	        return this.value(easedProgress, from, to);
	    }
	},
	
	/*
	    Caching functions used multiple times to reduce filesize and increase performance
	*/
	isNum = utils.isNum,
	    absolute = Math.abs;
	
	module.exports = calc;

/***/ },
/* 33 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	module.exports = function (values, terms, delimiter, chop) {
	    var combined = '',
	        key = '',
	        i = 0,
	        numTerms = terms.length;
	
	    for (; i < numTerms; i++) {
	        key = terms[i];
	
	        if (values.hasOwnProperty(key)) {
	            combined += values[key] + delimiter;
	        }
	    }
	
	    if (chop) {
	        combined = combined.slice(0, -chop);
	    }
	
	    return combined;
	};

/***/ },
/* 34 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var splitCommaDelimited = __webpack_require__(59),
	    functionBreak = __webpack_require__(60);
	
	module.exports = function (value, terms) {
	    var splitValue = {},
	        numTerms = terms.length,
	        colors = splitCommaDelimited(functionBreak(value)),
	        i = 0;
	
	    for (; i < numTerms; i++) {
	        splitValue[terms[i]] = colors[i] !== undefined ? colors[i] : 1;
	    }
	
	    return splitValue;
	};

/***/ },
/* 35 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	module.exports = function (value, prefix) {
	    return prefix + '(' + value + ')';
	};

/***/ },
/* 36 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	module.exports = {
	    color: {
	        min: 0,
	        max: 255,
	        round: true
	    },
	    opacity: {
	        min: 0,
	        max: 1
	    },
	    percent: {
	        min: 0,
	        max: 100,
	        unit: '%'
	    }
	};

/***/ },
/* 37 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var X = 'X',
	    Y = 'Y',
	    ALPHA = 'Alpha',
	    terms = {
	    colors: ['Red', 'Green', 'Blue', ALPHA],
	    positions: [X, Y, 'Z'],
	    dimensions: ['Top', 'Right', 'Bottom', 'Left'],
	    shadow: [X, Y, 'Radius', 'Spread', 'Color'],
	    hsl: ['Hue', 'Saturation', 'Lightness', ALPHA]
	};
	
	module.exports = terms;

/***/ },
/* 38 */
/***/ function(module, exports, __webpack_require__) {

	/*
	    Utility functions
	*/
	"use strict";
	
	var protectedProperties = ['scope', 'dom'],
	    isProtected = function isProtected(key) {
	    return protectedProperties.indexOf(key) !== -1;
	},
	
	/*
	    Get var type as string
	    
	    @param: Variable to test
	    @return [string]: Returns, for instance 'Object' if [object Object]
	*/
	varType = function varType(variable) {
	    return Object.prototype.toString.call(variable).slice(8, -1);
	};
	
	module.exports = {
	
	    /*
	        Iterate over an object and fire a callback for every item in it
	         @param [object]: Properties
	        @param [function]: Callback to fire
	    */
	    each: function each(props, callback) {
	        var keys = Object.keys(props),
	            numKeys = keys.length;
	
	        for (var i = 0; i < numKeys; i++) {
	            var key = keys[i],
	                prop = props[key];
	
	            if (callback(key, prop) === false) {
	                break;
	            }
	        }
	    },
	
	    /*
	        Has one object changed from the other
	        
	        Compares the two provided inputs and returns true if they are different
	        
	        @param [object]: Input A
	        @param [object]: Input B
	        @return [boolean]: True if different
	    */
	    hasChanged: function hasChanged(a, b) {
	        var hasChanged = false,
	            key = '';
	
	        for (key in b) {
	            if (a.hasOwnProperty(key) && b.hasOwnProperty(key)) {
	                if (a[key] !== b[key]) {
	                    hasChanged = true;
	                }
	            } else {
	                hasChanged = true;
	            }
	        }
	
	        return hasChanged;
	    },
	
	    /*
	        Is this var a number?
	        
	        @param: Variable to test
	        @return [boolean]: Returns true if typeof === 'number'
	    */
	    isNum: function isNum(num) {
	        return typeof num === 'number';
	    },
	
	    /*
	        Is this var an object?
	        
	        @param: Variable to test
	        @return [boolean]: Returns true if typeof === 'object'
	    */
	    isObj: function isObj(obj) {
	        return typeof obj === 'object';
	    },
	
	    /*
	        Is this var a function ? 
	        
	        @param: Variable to test
	        @return [boolean]: Returns true if this.varType === 'Function'
	    */
	    isFunc: function isFunc(obj) {
	        return varType(obj) === 'Function';
	    },
	
	    /*
	        Is this var a string ? 
	        
	        @param: Variable to test
	        @return [boolean]: Returns true if typeof str === 'string'
	    */
	    isString: function isString(str) {
	        return typeof str === 'string';
	    },
	
	    /*
	        Is this a relative value assignment?
	        
	        @param [string]: Variable to test
	        @return [boolean]: If this looks like a relative value assignment
	    */
	    isRelativeValue: function isRelativeValue(value) {
	        return value && value.indexOf && value.indexOf('=') > 0;
	    },
	
	    /*
	        Is this var an array ? 
	        
	        @param: Variable to test
	        @return [boolean]: Returns true if this.varType === 'Array'
	    */
	    isArray: function isArray(arr) {
	        return varType(arr) === 'Array';
	    },
	
	    /*
	        Copy object or array
	        
	        Checks whether base is an array or object and makes
	        appropriate copy
	        
	        @param [array || object]: Array or object to copy
	        @param [array || object]: New copy of array or object
	    */
	    copy: function copy(base) {
	        return this.isArray(base) ? this.copyArray(base) : this.copyObject(base);
	    },
	
	    /*
	        Deep copy an object
	        
	        Iterates over an object and creates a new copy of every item,
	        deep copying if it finds any objects/arrays
	        
	        @param [object]: Object to copy
	        @param [object]: New copy of object
	    */
	    copyObject: function copyObject(base) {
	        var newObject = {};
	
	        for (var key in base) {
	            if (base.hasOwnProperty(key)) {
	                newObject[key] = this.isObj(base[key]) && !isProtected(key) ? this.copy(base[key]) : base[key];
	            }
	        }
	
	        return newObject;
	    },
	
	    /*
	        Deep copy an array
	        
	        Loops through an array and creates a new copy of every item,
	        deep copying if it finds any objects/arrays
	        
	        @param [array]: Array to copy
	        @return [array]: New copy of array
	    */
	    copyArray: function copyArray(base) {
	        var newArray = [],
	            length = base.length,
	            i = 0;
	
	        for (; i < length; i++) {
	            newArray[i] = base[i];
	        }
	
	        return newArray;
	    },
	
	    /*
	        Non-destructive merge of object or array
	        
	        @param [array || object]: Array or object to use as base
	        @param [array || object]: Array or object to overwrite base with
	        @return [array || object]: New array or object
	    */
	    merge: function merge(base, overwrite) {
	        return this.isArray(base) ? this.copyArray(overwrite) : this.mergeObject(base, overwrite);
	    },
	
	    /*
	        Non-destructive merge of object
	        
	        @param [object]: Object to use as base
	        @param [object]: Object to overwrite base with
	        @return [object]: New object
	    */
	    mergeObject: function mergeObject(base, overwrite) {
	        var hasBase = this.isObj(base),
	            newObject = hasBase ? this.copy(base) : this.copy(overwrite),
	            key = '';
	
	        if (hasBase) {
	            for (key in overwrite) {
	                if (overwrite.hasOwnProperty(key)) {
	                    newObject[key] = this.isObj(overwrite[key]) && !isProtected(key) ? this.merge(base[key], overwrite[key]) : overwrite[key];
	                }
	            }
	        }
	        return newObject;
	    },
	
	    /*
	        Split a value into a value/unit object
	        
	            "200px" -> { value: 200, unit: "px" }
	            
	        @param [string]: Value to split
	        @return [object]: Object with value and unit props
	    */
	    splitValUnit: function splitValUnit(value) {
	        var splitVal = value.match(/(-?\d*\.?\d*)(.*)/);
	
	        return {
	            value: splitVal[1],
	            unit: splitVal[2]
	        };
	    },
	
	    /*
	        Create stepped version of 0-1 progress
	        
	        @param [number]: Current value
	        @param [int]: Number of steps
	        @return [number]: Stepped value
	    */
	    stepProgress: function stepProgress(progress, steps) {
	        var segment = 1 / (steps - 1),
	            target = 1 - 1 / steps,
	            progressOfTarget = Math.min(progress / target, 1);
	
	        return Math.floor(progressOfTarget / segment) * segment;
	    },
	
	    /*
	        Generate current timestamp
	        
	        @return [timestamp]: Current UNIX timestamp
	    */
	    currentTime: function currentTime() {
	        return typeof performance !== "undefined" ? performance.now() : new Date().getTime();
	    }
	
	};

/***/ },
/* 39 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	module.exports = function (value) {
	    return typeof value === 'string' ? value.split(' ') : [value];
	};

/***/ },
/* 40 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var each = __webpack_require__(38).each,
	    transformDictionary = __webpack_require__(61),
	    transformProps = transformDictionary.props,
	    TRANSLATE_Z = 'translateZ';
	
	module.exports = function (output, cache) {
	    var css = {},
	        transform = '',
	        transformHasZ = false;
	
	    // Loop through output, check for transform properties
	    each(output, function (key, rule) {
	        // If this is a transform property, add to transform string
	        if (transformProps[key]) {
	            transform += key + '(' + rule + ')';
	            transformHasZ = key === TRANSLATE_Z ? true : transformHasZ;
	
	            // Or just assign directly
	        } else {
	                if (rule !== cache[key]) {
	                    cache[key] = css[key] = rule;
	                }
	            }
	    });
	
	    // If we have transform properties, add translateZ
	    if (transform !== '') {
	        if (!transformHasZ) {
	            transform += ' ' + TRANSLATE_Z + '(0px)';
	        }
	
	        if (transform !== cache.transform) {
	            css.transform = transform;
	        }
	
	        cache.transform = transform;
	    }
	
	    return css;
	};

/***/ },
/* 41 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var TRANSLATE = 'translate';
	
	module.exports = {
	    x: TRANSLATE + 'X',
	    y: TRANSLATE + 'Y',
	    z: TRANSLATE + 'Z'
	};

/***/ },
/* 42 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var COLOR = 'color',
	    POSITIONS = 'positions',
	    DIMENSIONS = 'dimensions',
	    SHADOW = 'shadow',
	    ANGLE = 'angle',
	    ALPHA = 'alpha',
	    PX = 'px';
	
	module.exports = {
	    // Color properties
	    color: COLOR,
	    backgroundColor: COLOR,
	    outlineColor: COLOR,
	    fill: COLOR,
	    stroke: COLOR,
	    // Border
	    borderColor: COLOR,
	    borderTopColor: COLOR,
	    borderRightColor: COLOR,
	    borderBottomColor: COLOR,
	    borderLeftColor: COLOR,
	    borderRadius: PX,
	    // Dimensions
	    margin: DIMENSIONS,
	    padding: DIMENSIONS,
	    width: PX,
	    height: PX,
	    // Positions
	    backgroundPosition: POSITIONS,
	    perspectiveOrigin: POSITIONS,
	    transformOrigin: POSITIONS,
	    // Shadows
	    textShadow: SHADOW,
	    boxShadow: SHADOW,
	    // Transform properties
	    rotate: ANGLE,
	    rotateX: ANGLE,
	    rotateY: ANGLE,
	    rotateZ: ANGLE,
	    skewX: ANGLE,
	    skewY: ANGLE,
	    translateX: PX,
	    translateY: PX,
	    translateZ: PX,
	    perspective: PX,
	    opacity: ALPHA
	};

/***/ },
/* 43 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var each = __webpack_require__(38).each,
	    transformDictionary = __webpack_require__(61),
	    transformProps = transformDictionary.props,
	    zeroNotZero = 0.0001;
	
	module.exports = function (output, origin) {
	    var props = {},
	        hasTransform = false,
	        scale = output.scale !== undefined ? output.scale || zeroNotZero : output.scaleX || 1,
	        scaleY = output.scaleY !== undefined ? output.scaleY || zeroNotZero : scale || 1,
	        transformOriginX = origin.x,
	        transformOriginY = origin.y,
	        scaleTransformX = -transformOriginX * (scale * 1),
	        scaleTransformY = -transformOriginY * (scaleY * 1),
	        scaleReplaceX = transformOriginX / scale,
	        scaleReplaceY = transformOriginY / scaleY,
	        transform = {
	        translate: 'translate(' + output.translateX + ', ' + output.translateY + ') ',
	        scale: 'translate(' + scaleTransformX + ', ' + scaleTransformY + ') scale(' + scale + ', ' + scaleY + ') translate(' + scaleReplaceX + ', ' + scaleReplaceY + ') ',
	        rotate: 'rotate(' + output.rotate + ', ' + transformOriginX + ', ' + transformOriginY + ') ',
	        skewX: 'skewX(' + output.skewX + ') ',
	        skewY: 'skewY(' + output.skewY + ') '
	    };
	
	    each(output, function (key, value) {
	        if (transformProps[key]) {
	            hasTransform = true;
	        } else {
	            props[key] = value;
	        }
	    });
	
	    if (hasTransform) {
	        props.transform = '';
	
	        each(transform, function (key, value) {
	            var defaultValue = key === 'scale' ? '1' : '0';
	            props.transform += value.replace(/undefined/g, defaultValue);
	        });
	    }
	
	    return props;
	};

/***/ },
/* 44 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var COLOR = 'color',
	    SCALE = 'scale';
	
	module.exports = {
	    fill: COLOR,
	    stroke: COLOR,
	    scale: SCALE,
	    scaleX: SCALE,
	    scaleY: SCALE,
	    transformOrigin: 'positions',
	    d: 'complex'
	};

/***/ },
/* 45 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var STROKE = 'stroke';
	
	module.exports = {
	    opacity: STROKE + '-opacity',
	    width: STROKE + '-width',
	    miterlimit: STROKE + '-miterlimit'
	};

/***/ },
/* 46 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var Queue = function Queue() {
	    this.clear();
	};
	
	Queue.prototype = {
	
	    /*
	        Add a set of arguments to queue
	    */
	    add: function add() {
	        this.queue.push([].slice.call(arguments));
	    },
	
	    /*
	        Get next set of arguments from queue
	    */
	    next: function next(direction) {
	        var queue = this.queue,
	            returnVal = false,
	            index = this.index;
	
	        direction = arguments.length ? direction : 1;
	
	        // If our index is between 0 and the queue length, return that item
	        if (index >= 0 && index < queue.length) {
	            returnVal = queue[index];
	            this.index = index + direction;
	
	            // Or clear
	        } else {
	                this.clear();
	            }
	
	        return returnVal;
	    },
	
	    /*
	        Replace queue with empty array
	    */
	    clear: function clear() {
	        this.queue = [];
	        this.index = 0;
	    }
	};
	
	module.exports = Queue;

/***/ },
/* 47 */
/***/ function(module, exports, __webpack_require__) {

	/*
	    @param [string || NodeList || jQuery object]:
	        If string, treated as selector.
	        If not, treated as preexisting NodeList || jQuery object.
	*/
	'use strict';
	
	module.exports = function (selector) {
	    var nodes = typeof selector === 'string' ? document.querySelectorAll(selector) : selector,
	        elements = [];
	
	    // If jQuery selection, get array of Elements
	    if (nodes.get) {
	        elements = nodes.get();
	
	        // Or convert NodeList to array
	    } else if (nodes.length) {
	            elements = [].slice.call(nodes);
	
	            // Or if it's just an Element, put into array
	        } else {
	                elements.push(nodes);
	            }
	
	    return elements;
	};

/***/ },
/* 48 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var valueTypeManager = __webpack_require__(19),
	    calc = __webpack_require__(32),
	    utils = __webpack_require__(38),
	    each = utils.each,
	    Action = __webpack_require__(27),
	    defaultAction = new Action(),
	    Watch = __webpack_require__(62),
	    watcher = new Watch(),
	    createMapper = function createMapper(role, mappedValues) {
	    return function (name, val) {
	        mappedValues[role.map(name)] = val;
	    };
	},
	
	/*
	    Check all Actions for `onEnd`, return true if all are true
	     @param [Actor]
	    @param [boolean]
	    @returns [boolean]
	*/
	checkAllActionsHaveEnded = function checkAllActionsHaveEnded(actor, hasChanged) {
	    var hasEnded = true,
	        values = actor.state.values;
	
	    each(actor.activeActions, function (key, action) {
	        // Return if action has been deleted elsewhere
	        if (!action) {
	            return;
	        }
	
	        if (action.onFrame) {
	            action.onFrame.call(actor, values, actor, action);
	        }
	
	        if (action.onUpdate && hasChanged) {
	            action.onUpdate.call(actor, values, actor, action);
	        }
	
	        if (action.hasEnded && action.hasEnded(actor, hasChanged) === false) {
	            hasEnded = false;
	        } else {
	            if (action.onComplete) {
	                action.onComplete.call(actor, actor, action);
	            }
	            actor.unbindAction(key);
	        }
	    });
	
	    return hasEnded;
	},
	
	/*
	    Update the Actor and its values
	     @param [int]: Timestamp of rAF call
	    @param [int]: Time since last frame
	*/
	update = function update(framestamp, frameDuration) {
	    var numActiveValues = this.activeValues.length,
	        numActiveParents = this.activeParents.length,
	        numRoles = this.roles.length,
	        state = this.state,
	        hasChanged = false;
	
	    // Update values
	    for (var i = 0; i < numActiveValues; i++) {
	        // Get value and key
	        var key = this.activeValues[i];
	        var value = this.values[key];
	        var action = !value.action || value.action && !value.action.isActive ? defaultAction : value.action;
	
	        // Fire action onFrameStart if not already fired
	        if (action.onFrameStart && action.lastUpdate !== framestamp) {
	            action.onFrameStart(this, frameDuration, framestamp);
	            action.lastUpdate = framestamp;
	        }
	
	        // Calculate new value
	        var updatedValue = utils.isString(value.watch) ? watcher.process(this, value) : action.process(this, value, key, frameDuration);
	
	        // Limit if this action does that kind of thing
	        if (action.limit && value.hasRange) {
	            updatedValue = action.limit(updatedValue, value);
	        }
	
	        // Round value if round is true
	        if (value.round) {
	            updatedValue = Math.round(updatedValue);
	        }
	
	        // Update frameChange
	        value.frameChange = updatedValue - value.current;
	
	        // Calculate velocity if Action hasn't
	        if (!action.calculatesVelocity) {
	            value.velocity = calc.speedPerSecond(value.frameChange, frameDuration);
	        }
	
	        // Update current speed
	        value.speed = Math.abs(value.velocity);
	
	        // Check if value's changed
	        if (value.current !== updatedValue || this.firstFrame) {
	            hasChanged = true;
	        }
	
	        // Set new current
	        value.current = updatedValue;
	        var valueState = value.unit ? updatedValue + value.unit : updatedValue;
	
	        // Put value in state if no parent
	        if (!value.parent) {
	            state.values[key] = valueState;
	
	            // Or, add to parent state to be combined later
	        } else {
	                state[value.parent] = state[value.parent] || {};
	                state[value.parent][value.propName] = valueState;
	            }
	    }
	
	    // Update parent values from calculated children
	    for (var i = 0; i < numActiveParents; i++) {
	        var key = this.activeParents[i];
	        var value = this.values[key];
	
	        // Update parent value current property
	        value.current = valueTypeManager[value.type].combine(state[key], value.template);
	
	        // Update state
	        state.values[key] = value.current;
	    }
	
	    // Fire `frame` and `update` callbacks on all Roles
	    for (var i = 0; i < numRoles; i++) {
	        var role = this.roles[i];
	        var mappedValues = {};
	
	        each(state.values, createMapper(role, mappedValues));
	
	        if (role.frame) {
	            role.frame.call(this, mappedValues, this);
	        }
	
	        if (role.update && hasChanged) {
	            role.update.call(this, mappedValues, this);
	        }
	    }
	
	    // Reset hasChanged before further Actions might affect this
	    this.hasChanged = false;
	
	    if (this.isActive) {
	        this.isActive = false;
	
	        if (checkAllActionsHaveEnded(this, hasChanged)) {
	            // Fire `complete` callbacks
	            for (var i = 0; i < numRoles; i++) {
	                var role = this.roles[i];
	                if (role.complete) {
	                    role.complete.call(this, this);
	                }
	            }
	
	            if (!this.isActive) {
	                this.next();
	            }
	        } else {
	            this.isActive = true;
	            this.firstFrame = false;
	        }
	    }
	
	    this.framestamp = framestamp;
	};
	
	module.exports = update;

/***/ },
/* 49 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var valueTypesManager = __webpack_require__(19),
	    calc = __webpack_require__(32),
	    utils = __webpack_require__(38),
	    isNum = utils.isNum,
	    each = utils.each;
	
	var numericalValues = ['current', 'to', 'min', 'max', 'velocity', 'friction', 'spring'],
	    numNumericalValues = numericalValues.length,
	    defaultValue = {
	    current: 0,
	    velocity: 0,
	    speed: 0,
	    frameChange: 0
	};
	
	function checkNumericalValue(name) {
	    return numericalValues.indexOf(name) > -1;
	}
	
	/*
	    Check Role typeMaps to see if this value name has been mapped
	    to a specific value type
	
	    @param [string]
	    @param [array]
	    @returns [string]: Value type
	*/
	function checkRoles(name, roles) {
	    var valueType;
	
	    each(roles, function (key, role) {
	        if (role._typeMap) {
	            valueType = role._typeMap[role.map(name)] || valueType;
	        }
	    });
	
	    return valueType;
	}
	
	/*
	    Check value for special type
	
	    @param [object]
	    @param [object]
	    @param [object]
	    @param [string]
	    @returns [string || false]
	*/
	function checkValueType(existingValue, newValue, scope, valueName) {
	    var valueType;
	
	    // Check existing value for type already set
	    if (existingValue && existingValue.type) {
	        valueType = existingValue.type;
	    } else {
	        // Or check Role _typeMap properties
	        if (scope.roles) {
	            valueType = checkRoles(valueName, scope.roles);
	        }
	
	        // Finally run tests
	        if (!valueType && utils.isString(newValue.current)) {
	            valueType = valueTypesManager.test(newValue.current);
	        }
	    }
	
	    return valueType;
	}
	
	/*
	    Resolve a property
	
	    @param [string]
	    @param [string || function || number]
	    @param [object]
	    @param [object]
	    @returns [number]
	*/
	function resolve(name, prop, value, scope) {
	    var isNumericalValue = checkNumericalValue(name);
	
	    // If function, resolve
	    if (utils.isFunc(prop) && isNumericalValue) {
	        prop = prop.call(scope, scope);
	    }
	
	    // If string, check for relative numbers and units
	    if (utils.isString(prop)) {
	        // If relative value
	        if (prop.indexOf('=') > 0) {
	            prop = calc.relativeValue(value.current, prop);
	        }
	
	        // If unit
	        if (isNumericalValue) {
	            splitUnit(prop, value);
	        }
	    }
	
	    if (isNumericalValue) {
	        prop = parseFloat(prop);
	    }
	
	    return prop;
	}
	
	/*
	    Split a value into sub-values
	
	    @param [string]
	    @param [object]
	    @param [object]
	    @param [valueTypeHandler]
	    @returns [object]
	*/
	function split(name, value, scope, valueTypeHandler) {
	    var splitValues = {},
	        i = 0;
	
	    var _loop = function () {
	        var propName = numericalValues[i];
	        var splitProp = {};
	
	        if (value.hasOwnProperty(propName)) {
	            var valueProp = value[propName];
	
	            // If we need to first resolve this, resolve
	            if (utils.isFunc(valueProp)) {
	                valueProp = valueProp.call(scope, scope);
	            }
	
	            if (!utils.isString(valueProp)) {
	                return 'continue';
	            }
	
	            splitProp = valueTypeHandler.split(valueProp);
	
	            // Assign split properties to each child value
	            each(splitProp, function (key, prop) {
	                // Create new value if none exists
	                splitValues[key] = splitValues[key] || utils.copy(valueTypesManager.defaultProps(value.type, key));
	                splitValues[key][propName] = prop;
	
	                if (utils.isString(splitProp[key])) {
	                    splitUnit(splitValues[key][propName], splitValues[key]);
	                }
	            });
	        }
	    };
	
	    for (; i < numNumericalValues; i++) {
	        var _ret = _loop();
	
	        if (_ret === 'continue') continue;
	    }
	
	    return splitValues;
	}
	
	/*
	    Split value into number and unit, and set unit to value
	
	    @param [string]
	    @param [object]
	*/
	function splitUnit(property, hostValue) {
	    if (utils.isNum(property)) {
	        return property;
	    }
	    var returnVal = property;
	
	    var _utils$splitValUnit = utils.splitValUnit(property);
	
	    var value = _utils$splitValUnit.value;
	    var unit = _utils$splitValUnit.unit;
	
	    if (!isNaN(value)) {
	        returnVal = value;
	        if (unit) {
	            hostValue.unit = unit;
	        }
	    }
	
	    return returnVal;
	}
	
	/*
	    Preprocess incoming values, splitting non-numerical values
	    into sub-values ie hex
	
	    @param [object]
	    @param [object]
	    @param [object]
	    @param [string]
	*/
	function preprocess(existing, incoming, scope, defaultProp) {
	    var values = {};
	
	    each(incoming, function (key, value) {
	        var existingValue = existing[key],
	            newValue = {};
	
	        if (utils.isObj(value)) {
	            newValue = value;
	        } else {
	            newValue[defaultProp] = value;
	        }
	
	        // If value doesn't have a special type, check for one
	        newValue.type = checkValueType(existingValue, newValue, scope, key);
	        newValue.watch = utils.isString(newValue.watch) ? newValue.watch : undefined;
	
	        values[key] = newValue;
	
	        // If we have a type property, split/assign default props
	        if (newValue.type) {
	            var typeHandler = valueTypesManager[newValue.type];
	
	            // If valueType handler has a split function, split this value
	            if (typeHandler.split) {
	                var splitValues = split(key, newValue, scope, typeHandler);
	                newValue.children = {};
	
	                each(splitValues, function (childName, childValue) {
	                    childValue = utils.merge(newValue, childValue);
	                    childValue.parent = childValue.name = key;
	                    childValue.propName = childName;
	
	                    delete childValue.type;
	                    delete childValue.children;
	
	                    newValue.children[childName] = values[key + childName] = childValue;
	                });
	
	                if (typeHandler.template) {
	                    newValue.template = existingValue ? existingValue.template : typeHandler.template(newValue.current);
	                }
	
	                // Or just assign default properties for this value
	            } else {
	                    values[key] = utils.merge(valueTypesManager.defaultProps(newValue.type, key), newValue);
	                }
	        }
	    });
	
	    return values;
	}
	
	module.exports = {
	
	    /*
	        Flip value target/origin
	    */
	    flip: function flip(value) {
	        var target = value.target !== undefined ? value.target : value.current;
	        value.target = value.to = value.origin;
	        value.origin = target;
	    },
	
	    /*
	        Merge existing and incoming values, resolving properties
	        set as functions and splitting non-numerical values ie hex
	         @param [object]
	        @param [object]
	        @param [object]
	        @param [string] (optional)
	        @param [object]
	        @returns [object]: New values object
	    */
	    process: function process(existing, incoming, inherit, defaultProp, scope) {
	        existing = existing || {};
	        defaultProp = defaultProp || 'current';
	        var preprocessed = preprocess(existing, incoming, scope, defaultProp);
	
	        each(preprocessed, function (key, value) {
	            var newValue = existing[key] || utils.copy(defaultValue),
	                hasChildren = value.children !== undefined,
	                defaultActionValue = inherit.action ? inherit.action.getDefaultValue() : {};
	
	            value.action = inherit.action;
	
	            each(defaultActionValue, function (propName, defaultActionProp) {
	                newValue[propName] = inherit.hasOwnProperty(propName) && !value.hasOwnProperty(propName) ? inherit[propName] : defaultActionProp;
	            });
	
	            each(value, function (valueName, valueProp) {
	                // If property is not undefined or a number, resolve
	                if (valueProp !== undefined && !isNum(valueProp) && !hasChildren) {
	                    valueProp = resolve(valueName, valueProp, newValue, scope);
	                }
	
	                newValue[valueName] = valueProp;
	
	                // Set internal target if this property is 'to'
	                if (valueName === 'to') {
	                    newValue.target = newValue.to;
	                }
	            });
	
	            newValue.origin = newValue.current;
	            newValue.hasRange = isNum(newValue.min) || isNum(newValue.max) ? true : false;
	
	            existing[key] = newValue;
	            scope.updateOrder(key, utils.isString(newValue.watch), hasChildren);
	        });
	
	        return existing;
	    }
	};

/***/ },
/* 50 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	var Role = __webpack_require__(25);
	
	module.exports = new Role({
	    init: function init(actor) {
	        if (actor.init) {
	            actor.init(actor);
	        }
	    },
	
	    start: function start(actor) {
	        if (actor.onStart) {
	            actor.onStart(actor);
	        }
	    },
	
	    frame: function frame(state, actor) {
	        if (actor.onFrame) {
	            actor.onFrame(state, actor);
	        }
	    },
	
	    update: function update(state, actor) {
	        if (actor.onUpdate) {
	            actor.onUpdate(state, actor);
	        }
	    },
	
	    complete: function complete(actor) {
	        if (actor.onComplete) {
	            actor.onComplete(actor);
	        }
	    }
	});

/***/ },
/* 51 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var // [number]: Default max size of history
	maxHistorySize = 3,
	
	/*
	    History constructor
	    
	    @param [var]: Variable to store in first history slot
	    @param [int] (optional): Maximum size of history
	*/
	History = function History(obj, max) {
	    this.max = max || maxHistorySize;
	    this.entries = [];
	    this.add(obj);
	};
	
	History.prototype = {
	
	    /*
	        Push new var to history
	        
	        Shift out oldest entry if we've reached maximum capacity
	        
	        @param [var]: Variable to push into history.entries
	    */
	    add: function add(obj) {
	        var currentSize = this.getSize();
	
	        this.entries.push(obj);
	
	        if (currentSize >= this.max) {
	            this.entries.shift();
	        }
	    },
	
	    /*
	        Get variable at specified index
	         @param [int]: Index
	        @return [var]: Var found at specified index
	    */
	    get: function get(i) {
	        i = typeof i === 'number' ? i : this.getSize() - 1;
	
	        return this.entries[i];
	    },
	
	    /*
	        Get the second newest history entry
	        
	        @return [var]: Entry found at index size - 2
	    */
	    getPrevious: function getPrevious() {
	        return this.get(this.getSize() - 2);
	    },
	
	    /*
	        Get current history size
	        
	        @return [int]: Current length of entries.length
	    */
	    getSize: function getSize() {
	        return this.entries.length;
	    }
	
	};
	
	module.exports = History;

/***/ },
/* 52 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
	
	var Controls = (function () {
	    function Controls(actor, action, hasStarted) {
	        _classCallCheck(this, Controls);
	
	        this.actor = actor;
	        this.action = action;
	
	        if (hasStarted) {
	            this.id = this.bindAction();
	            this.action.activate();
	        }
	    }
	
	    Controls.prototype.start = function start(input) {
	        this.id = this.bindAction();
	        this.actor.start(this.id, input);
	        this.action.activate();
	        return this;
	    };
	
	    Controls.prototype.stop = function stop() {
	        this.actor.unbindAction(this.id);
	        this.action.deactivate();
	
	        return this;
	    };
	
	    Controls.prototype.pause = function pause() {
	        this.action.deactivate();
	        return this;
	    };
	
	    Controls.prototype.resume = function resume() {
	        this.action.activate();
	        return this;
	    };
	
	    Controls.prototype.toggle = function toggle() {
	        var resume = this.actor.hasAction(this.id) ? this.resume : this.start;
	        return this.action.isActive ? this.pause() : resume.call(this);
	    };
	
	    Controls.prototype.then = function then() {
	        var _actor;
	
	        (_actor = this.actor).then.apply(_actor, arguments);
	        return this;
	    };
	
	    Controls.prototype.bindAction = function bindAction() {
	        return this.actor.bindAction(this.action, this.id);
	    };
	
	    return Controls;
	})();
	
	module.exports = Controls;

/***/ },
/* 53 */
/***/ function(module, exports, __webpack_require__) {

	/*
	    Easing functions
	    ----------------------------------------
	    
	    Generates and provides easing functions based on baseFunction definitions
	    
	    A call to easingFunction.get('functionName') returns a function that can be passed:
	        @param [number]: Progress 0-1
	        @param [number] (optional): Amp modifier, only accepted in some easing functions
	                                    and is used to adjust overall strength
	        @return [number]: Eased progress
	        
	    We can generate new functions by sending an easing function through easingFunction.extend(name, method).
	    Which will make nameIn, nameOut and nameInOut functions available to use.
	        
	    Easing functions from Robert Penner
	    http://www.robertpenner.com/easing/
	        
	    Bezier curve interpretor created from Gaëtan Renaudeau's original BezierEasing  
	    https://github.com/gre/bezier-easing/blob/master/index.js  
	    https://github.com/gre/bezier-easing/blob/master/LICENSE
	*/
	"use strict";
	
	var Easing = __webpack_require__(26),
	    easingFunction,
	
	// Generate easing function with provided power
	generatePowerEasing = function generatePowerEasing(power) {
	    return function (progress) {
	        return Math.pow(progress, power);
	    };
	},
	
	/*
	    Each of these base functions is an easeIn
	    
	    On init, we use EasingFunction.mirror and .reverse to generate easeInOut and
	    easeOut functions respectively.
	*/
	baseEasing = {
	    circ: function circ(progress) {
	        return 1 - Math.sin(Math.acos(progress));
	    },
	    back: function back(progress) {
	        var strength = 1.5;
	
	        return progress * progress * ((strength + 1) * progress - strength);
	    }
	};
	
	// Generate power easing easing
	['ease', 'cubic', 'quart', 'quint'].forEach(function (easingName, i) {
	    baseEasing[easingName] = generatePowerEasing(i + 2);
	});
	
	// Generate in/out/inOut variations
	for (var key in baseEasing) {
	    if (baseEasing.hasOwnProperty(key)) {
	        easingFunction = new Easing(baseEasing[key]);
	        baseEasing[key + 'In'] = easingFunction['in'];
	        baseEasing[key + 'Out'] = easingFunction.out;
	        baseEasing[key + 'InOut'] = easingFunction.inOut;
	    }
	}
	
	/*
	    Linear easing adjustment
	    
	    The default easing method, not added with .extend as it has no Out or InOut
	    variation.
	    
	    @param [number]: Progress, from 0-1
	    @return [number]: Unadjusted progress
	*/
	baseEasing.linear = function (progress) {
	    return progress;
	};
	
	module.exports = baseEasing;

/***/ },
/* 54 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var Controls = __webpack_require__(52);
	
	var TweenControls = (function (_Controls) {
	    _inherits(TweenControls, _Controls);
	
	    function TweenControls() {
	        _classCallCheck(this, TweenControls);
	
	        _Controls.apply(this, arguments);
	    }
	
	    TweenControls.prototype.restart = function restart() {
	        this.action.restart();
	        return this;
	    };
	
	    TweenControls.prototype.reverse = function reverse() {
	        this.action.reverse();
	        return this;
	    };
	
	    TweenControls.prototype.seek = function seek(progress) {
	        if (!this.actor.hasAction(this.id)) {
	            this.start().pause();
	        }
	
	        this.action.elapsed = this.action.duration * progress;
	
	        if (!this.action.isActive) {
	            this.action.activate();
	            this.actor.process.fire();
	            this.action.deactivate();
	        }
	
	        return this;
	    };
	
	    return TweenControls;
	})(Controls);
	
	module.exports = TweenControls;

/***/ },
/* 55 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var calc = __webpack_require__(32),
	    utils = __webpack_require__(38),
	    speedPerFrame = calc.speedPerFrame;
	
	/*
	    Add core physics simulations
	*/
	var simulations = {
	    /*
	        Velocity
	        
	        The default .run() simulation.
	        
	        Applies any set deceleration and acceleration to existing velocity
	    */
	    velocity: function velocity(value, duration) {
	        value.velocity = value.velocity - speedPerFrame(value.deceleration, duration) + speedPerFrame(value.acceleration, duration);
	
	        return simulations.friction(value, duration);
	    },
	
	    /*
	        Glide
	        
	        Emulates touch device scrolling effects with exponential decay
	        http://ariya.ofilabs.com/2013/11/javascript-kinetic-scrolling-part-2.html
	    */
	    glide: function glide(value, duration, started) {
	        var timeUntilFinished = -utils.currentTime() - started,
	            delta = -value.to * Math.exp(timeUntilFinished / value.timeConstant);
	
	        return value.to + delta - value.current;
	    },
	
	    /*
	        Friction
	         Apply friction to the current value
	        TODO: Make this framerate-independent
	    */
	    friction: function friction(value, duration) {
	        var newVelocity = speedPerFrame(value.velocity, duration) * (1 - value.friction);
	
	        return calc.speedPerSecond(newVelocity, duration);
	    },
	
	    spring: function spring(value, duration) {
	        var distance = value.to - value.current;
	
	        value.velocity += distance * speedPerFrame(value.spring, duration);
	
	        return simulations.friction(value, duration);
	    },
	
	    bounce: function bounce(value) {
	        var distance = 0,
	            to = value.to,
	            current = value.current,
	            bounce = value.bounce;
	
	        // If we're using glide simulation we have to flip our target too
	        if (value.simulate === 'glide') {
	            distance = to - current;
	            value.to = current - distance * bounce;
	        }
	
	        return value.velocity *= -bounce;
	    },
	
	    capture: function capture(value, target) {
	        value.to = target;
	        value.simulate = 'spring';
	        value.capture = value.min = value.max = undefined;
	    }
	};
	
	module.exports = simulations;

/***/ },
/* 56 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var Input = __webpack_require__(22),
	    currentPointer,
	    // Sort this out for multitouch
	
	TOUCHMOVE = 'touchmove',
	    MOUSEMOVE = 'mousemove',
	
	/*
	    Convert event into point
	    
	    Scrape the x/y coordinates from the provided event
	    
	    @param [event]: Original pointer event
	    @param [boolean]: True if touch event
	    @return [object]: x/y coordinates of event
	*/
	eventToPoint = function eventToPoint(event, isTouchEvent) {
	    var touchChanged = isTouchEvent ? event.changedTouches[0] : false;
	
	    return {
	        x: touchChanged ? touchChanged.clientX : event.pageX,
	        y: touchChanged ? touchChanged.clientY : event.pageY
	    };
	},
	
	/*
	    Get actual event
	    
	    Checks for jQuery's .originalEvent if present
	    
	    @param [event | jQuery event]
	    @return [event]: The actual JS event  
	*/
	getActualEvent = function getActualEvent(event) {
	    return event.originalEvent || event;
	},
	
	/*
	    Pointer constructor
	*/
	Pointer = function Pointer(e) {
	    var event = getActualEvent(e),
	        // In case of jQuery event
	    isTouch = event.touches ? true : false,
	        startPoint = eventToPoint(event, isTouch);
	
	    this.update(startPoint);
	    this.isTouch = isTouch;
	    this.bindEvents();
	},
	    proto = Pointer.prototype = new Input();
	
	/*
	    Bind move event
	*/
	proto.bindEvents = function () {
	    this.moveEvent = this.isTouch ? TOUCHMOVE : MOUSEMOVE;
	
	    currentPointer = this;
	
	    document.documentElement.addEventListener(this.moveEvent, this.onMove);
	};
	
	/*
	    Unbind move event
	*/
	proto.unbindEvents = function () {
	    document.documentElement.removeEventListener(this.moveEvent, this.onMove);
	};
	
	/*
	    Pointer onMove event handler
	    
	    @param [event]: Pointer move event
	*/
	proto.onMove = function (e) {
	    var newPoint = eventToPoint(e, currentPointer.isTouch);
	    e = getActualEvent(e);
	    e.preventDefault();
	    currentPointer.update(newPoint);
	};
	
	proto.stop = function () {
	    this.unbindEvents();
	};
	
	module.exports = Pointer;

/***/ },
/* 57 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var theLoop = __webpack_require__(63),
	    ProcessManager = function ProcessManager() {
	    this.activeIds = [];
	    this.activeProcesses = {};
	    this.deactivateQueue = [];
	    theLoop.setCallback(this, this.fireActive);
	};
	
	ProcessManager.prototype = {
	
	    /*
	        [int]: Used for process ID
	    */
	    processCounter: 0,
	
	    /*
	        [int]: Number of active processes
	    */
	    activeCount: 0,
	
	    /*
	        Get the process with a given index
	        
	        @param [int]: Index of process
	        @return [Process]
	    */
	    getProcess: function getProcess(i) {
	        return this.activeProcesses[i];
	    },
	
	    /*
	        Get number of active processes
	        
	        @return [int]: Number of active processes
	    */
	    getActiveCount: function getActiveCount() {
	        return this.activeCount;
	    },
	
	    /*
	        Get active tokens
	         @return [array]: Active tokens
	    */
	    getActive: function getActive() {
	        return this.activeIds;
	    },
	
	    /*
	        Get the length of the deactivate queue
	        
	        @return [int]: Length of queue
	    */
	    getQueueLength: function getQueueLength() {
	        return this.deactivateQueue.length;
	    },
	
	    /*
	        Fire all active processes
	        
	        @param [int]: Timestamp of executing frames
	        @param [int]: Time since previous frame
	        @return [boolean]: True if active processes found
	    */
	    fireActive: function fireActive(framestamp, elapsed) {
	        var process,
	            activeCount = 0,
	            activeIds = [],
	            i = 0;
	
	        // Purge and check active count before execution
	        this.purge();
	        activeCount = this.getActiveCount();
	        activeIds = this.getActive();
	
	        // Loop through active processes and fire callback
	        for (; i < activeCount; i++) {
	            process = this.getProcess(activeIds[i]);
	
	            if (process) {
	                process.fire(framestamp, elapsed);
	            }
	        }
	
	        // Repurge and recheck active count after execution
	        this.purge();
	        activeCount = this.getActiveCount();
	
	        // Return true if we still have active processes, or false if none
	        return activeCount ? true : false;
	    },
	
	    /*
	        Register a new process
	        
	        @param [Process]
	        @return [int]: Index of process to be used as ID
	    */
	    register: function register() {
	        return this.processCounter++;
	    },
	
	    /*
	        Activate a process
	        
	        @param [int]: Index of active process
	    */
	    activate: function activate(process, i) {
	        var queueIndex = this.deactivateQueue.indexOf(i),
	            isQueued = queueIndex > -1,
	            isActive = this.activeIds.indexOf(i) > -1;
	
	        // Remove from deactivateQueue if in there
	        if (isQueued) {
	            this.deactivateQueue.splice(queueIndex, 1);
	        }
	
	        // Add to active processes array if not already in there
	        if (!isActive) {
	            this.activeIds.push(i);
	            this.activeProcesses[i] = process;
	            this.activeCount++;
	            theLoop.start();
	        }
	    },
	
	    /*
	        Deactivate a process
	        
	        @param [int]: Index of process to add to deactivate queue
	    */
	    deactivate: function deactivate(i) {
	        var queue = this.deactivateQueue;
	        if (queue.indexOf(i) === -1) {
	            queue.push(i);
	        }
	    },
	
	    /*
	        Purge the deactivate queue
	    */
	    purge: function purge() {
	        var queueLength = this.getQueueLength(),
	            activeIdIndex = 0,
	            idToDelete = 0;
	
	        while (queueLength--) {
	            idToDelete = this.deactivateQueue[queueLength];
	            activeIdIndex = this.activeIds.indexOf(idToDelete);
	
	            // If process in active list deactivate
	            if (activeIdIndex > -1) {
	                this.activeIds.splice(activeIdIndex, 1);
	                this.activeCount--;
	                delete this.activeProcesses[idToDelete];
	            }
	        }
	
	        this.deactivateQueue = [];
	    }
	
	};
	
	module.exports = new ProcessManager();

/***/ },
/* 58 */
/***/ function(module, exports, __webpack_require__) {

	/*
	    Bezier function generator
	        
	    Gaëtan Renaudeau's BezierEasing
	    https://github.com/gre/bezier-easing/blob/master/index.js  
	    https://github.com/gre/bezier-easing/blob/master/LICENSE
	    You're a hero
	    
	    Use
	    
	        var easeOut = new Bezier(.17,.67,.83,.67),
	            x = easeOut(0.5); // returns 0.627...
	*/
	"use strict";
	
	var NEWTON_ITERATIONS = 8,
	    NEWTON_MIN_SLOPE = 0.001,
	    SUBDIVISION_PRECISION = 0.0000001,
	    SUBDIVISION_MAX_ITERATIONS = 10,
	    K_SPLINE_TABLE_SIZE = 11,
	    K_SAMPLE_STEP_SIZE = 1.0 / (K_SPLINE_TABLE_SIZE - 1.0),
	    FLOAT_32_SUPPORTED = typeof Float32Array !== 'undefined',
	    a = function a(a1, a2) {
	    return 1.0 - 3.0 * a2 + 3.0 * a1;
	},
	    b = function b(a1, a2) {
	    return 3.0 * a2 - 6.0 * a1;
	},
	    c = function c(a1) {
	    return 3.0 * a1;
	},
	    getSlope = function getSlope(t, a1, a2) {
	    return 3.0 * a(a1, a2) * t * t + 2.0 * b(a1, a2) * t + c(a1);
	},
	    calcBezier = function calcBezier(t, a1, a2) {
	    return ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t;
	},
	
	/*
	    Bezier constructor
	*/
	Bezier = function Bezier(mX1, mY1, mX2, mY2) {
	    var sampleValues = FLOAT_32_SUPPORTED ? new Float32Array(K_SPLINE_TABLE_SIZE) : new Array(K_SPLINE_TABLE_SIZE),
	        _precomputed = false,
	        binarySubdivide = function binarySubdivide(aX, aA, aB) {
	        var currentX,
	            currentT,
	            i = 0;
	
	        do {
	            currentT = aA + (aB - aA) / 2.0;
	            currentX = calcBezier(currentT, mX1, mX2) - aX;
	            if (currentX > 0.0) {
	                aB = currentT;
	            } else {
	                aA = currentT;
	            }
	        } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);
	
	        return currentT;
	    },
	        newtonRaphsonIterate = function newtonRaphsonIterate(aX, aGuessT) {
	        var i = 0,
	            currentSlope = 0.0,
	            currentX;
	
	        for (; i < NEWTON_ITERATIONS; ++i) {
	            currentSlope = getSlope(aGuessT, mX1, mX2);
	
	            if (currentSlope === 0.0) {
	                return aGuessT;
	            }
	
	            currentX = calcBezier(aGuessT, mX1, mX2) - aX;
	            aGuessT -= currentX / currentSlope;
	        }
	
	        return aGuessT;
	    },
	        calcSampleValues = function calcSampleValues() {
	        for (var i = 0; i < K_SPLINE_TABLE_SIZE; ++i) {
	            sampleValues[i] = calcBezier(i * K_SAMPLE_STEP_SIZE, mX1, mX2);
	        }
	    },
	        getTForX = function getTForX(aX) {
	        var intervalStart = 0.0,
	            currentSample = 1,
	            lastSample = K_SPLINE_TABLE_SIZE - 1,
	            dist = 0.0,
	            guessForT = 0.0,
	            initialSlope = 0.0;
	
	        for (; currentSample != lastSample && sampleValues[currentSample] <= aX; ++currentSample) {
	            intervalStart += K_SAMPLE_STEP_SIZE;
	        }
	
	        --currentSample;
	
	        dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);
	        guessForT = intervalStart + dist * K_SAMPLE_STEP_SIZE;
	
	        initialSlope = getSlope(guessForT, mX1, mX2);
	
	        // If slope is greater than min
	        if (initialSlope >= NEWTON_MIN_SLOPE) {
	            return newtonRaphsonIterate(aX, guessForT);
	            // Slope is equal to min
	        } else if (initialSlope === 0.0) {
	                return guessForT;
	                // Slope is less than min
	            } else {
	                    return binarySubdivide(aX, intervalStart, intervalStart + K_SAMPLE_STEP_SIZE);
	                }
	    },
	        precompute = function precompute() {
	        _precomputed = true;
	        if (mX1 != mY1 || mX2 != mY2) {
	            calcSampleValues();
	        }
	    },
	
	    /*
	        Generated function
	        
	        Returns value 0-1 based on X
	    */
	    f = function f(aX) {
	        var returnValue;
	
	        if (!_precomputed) {
	            precompute();
	        }
	
	        // If linear gradient, return X as T
	        if (mX1 === mY1 && mX2 === mY2) {
	            returnValue = aX;
	
	            // If at start, return 0
	        } else if (aX === 0) {
	                returnValue = 0;
	
	                // If at end, return 1
	            } else if (aX === 1) {
	                    returnValue = 1;
	                } else {
	                    returnValue = calcBezier(getTForX(aX), mY1, mY2);
	                }
	
	        return returnValue;
	    };
	
	    return f;
	};
	
	module.exports = Bezier;

/***/ },
/* 59 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	module.exports = function (value) {
	    return typeof value === 'string' ? value.split(/,\s*/) : [value];
	};

/***/ },
/* 60 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	module.exports = function (value) {
	    return value.substring(value.indexOf('(') + 1, value.lastIndexOf(')'));
	};

/***/ },
/* 61 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var positionTerms = __webpack_require__(37).positions,
	    numPositionTerms = positionTerms.length,
	    TRANSFORM_PERSPECTIVE = 'transformPerspective',
	    SCALE = 'scale',
	    ROTATE = 'rotate',
	    terms = {
	    funcs: ['translate', SCALE, ROTATE, 'skew', TRANSFORM_PERSPECTIVE],
	    props: {} // objects are faster at direct lookups
	};
	
	// Create transform terms
	(function () {
	    var funcs = terms.funcs,
	        props = terms.props,
	        numFuncs = funcs.length,
	        i = 0,
	        createProps = function createProps(funcName) {
	        var j = 0;
	
	        for (; j < numPositionTerms; j++) {
	            props[funcName + positionTerms[j]] = true;
	        }
	    };
	
	    // Manually add skew and transform perspective 
	    props[ROTATE] = props[SCALE] = props[TRANSFORM_PERSPECTIVE] = true;
	
	    // Loop over each function name and create function/property terms
	    for (; i < numFuncs; i++) {
	        createProps(funcs[i]);
	    }
	})();
	
	module.exports = terms;

/***/ },
/* 62 */
/***/ function(module, exports, __webpack_require__) {

	'use strict';
	
	function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
	
	function _inherits(subClass, superClass) { if (typeof superClass !== 'function' && superClass !== null) { throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; }
	
	var Action = __webpack_require__(27),
	    calc = __webpack_require__(32),
	    STRING = 'string',
	
	/*
	    Translate our mapLink value into mapTo
	    
	    @param [number]: Calculated value from linked value
	    @param [Value || object]: Linked value or empty object if we're linking to input
	    @param [array]: List of numbers relating to linked value
	    @param [array]: List of numbers relating to this value
	*/
	findMappedValue = function findMappedValue(newValue, linkedValue, toValue, mapLink, mapTo) {
	    var mapLength = mapLink.length,
	        i = 1,
	        lastLinkValue,
	        thisLinkValue,
	        lastToValue,
	        thisToValue;
	
	    for (; i < mapLength; i++) {
	        // Assign values from array, or if they're strings, look for them in linkedValue
	        lastLinkValue = typeof mapLink[i - 1] === STRING ? linkedValue[mapLink[i - 1]] : mapLink[i - 1];
	        thisLinkValue = typeof mapLink[i] === STRING ? linkedValue[mapLink[i]] : mapLink[i];
	        lastToValue = typeof mapTo[i - 1] === STRING ? toValue[mapTo[i - 1]] : mapTo[i - 1];
	        thisToValue = typeof mapTo[i] === STRING ? toValue[mapTo[i]] : mapTo[i];
	
	        // Check if we've gone past our calculated value, or if we're at the end of the array
	        if (newValue < thisLinkValue || i === mapLength - 1) {
	            newValue = calc.value(calc.restricted(calc.progress(newValue, lastLinkValue, thisLinkValue), 0, 1), lastToValue, thisToValue);
	            break;
	        }
	    }
	
	    return newValue;
	};
	
	var Watch = (function (_Action) {
	    _inherits(Watch, _Action);
	
	    function Watch() {
	        _classCallCheck(this, Watch);
	
	        for (var _len = arguments.length, args = Array(_len), _key = 0; _key < _len; _key++) {
	            args[_key] = arguments[_key];
	        }
	
	        _Action.call.apply(_Action, [this].concat(args));
	        this.isActive = true;
	    }
	
	    /*
	        Process this value
	        
	        First check if this value exists as a Value, if not
	        check within Input (if we have one)
	            
	        @param [Actor]
	        @param [Value]: Current value
	        @param [string]: Key of current value
	        @return [number]: Calculated value
	    */
	
	    Watch.prototype.process = function process(actor, value, key) {
	        var values = actor.values,
	            newValue = value.current,
	            watchedKey = value.watch,
	            watchedValue = values[watchedKey] ? values[watchedKey] : {},
	            inputOffset = value.action ? value.action.inputOffset : false;
	
	        // First look at Action and check value isn't linking itself
	        if (watchedValue.current !== undefined && key !== watchedKey) {
	            newValue = watchedValue.current;
	
	            // Then check values in Input
	        } else if (inputOffset && inputOffset.hasOwnProperty(watchedKey)) {
	                newValue = value.action.process(actor, value, watchedKey);
	            }
	
	        // If we have mapFrom and mapTo properties, translate the new value
	        if (value.mapFrom && value.mapTo) {
	            value.unmapped = newValue;
	            newValue = findMappedValue(newValue, watchedValue, value, value.mapFrom, value.mapTo);
	        }
	
	        return newValue;
	    };
	
	    return Watch;
	})(Action);
	
	module.exports = Watch;

/***/ },
/* 63 */
/***/ function(module, exports, __webpack_require__) {

	/*
	    The loop
	*/
	"use strict";
	
	var Timer = __webpack_require__(64),
	    tick = __webpack_require__(65),
	    Loop = function Loop() {
	    this.timer = new Timer();
	};
	
	Loop.prototype = {
	
	    /*
	        [boolean]: Current status of animation loop
	    */
	    isRunning: false,
	
	    /*
	        Fire all active processes once per frame
	    */
	    frame: function frame() {
	        var self = this;
	
	        tick(function (framestamp) {
	            self.timer.update(framestamp);
	            var isActive = self.callback.call(self.scope, framestamp, self.timer.getElapsed());
	
	            if (isActive) {
	                self.frame();
	            } else {
	                self.stop();
	            }
	        });
	    },
	
	    /*
	        Start loop
	    */
	    start: function start() {
	        // Make sure we're not already running a loop
	        if (!this.isRunning) {
	            this.timer.clock();
	            this.isRunning = true;
	            this.frame();
	        }
	    },
	
	    /*
	        Stop the loop
	    */
	    stop: function stop() {
	        this.isRunning = false;
	    },
	
	    /*
	        Set the callback to run every frame
	        
	        @param [Object]: Execution context
	        @param [function]: Callback to fire
	    */
	    setCallback: function setCallback(scope, callback) {
	        this.scope = scope;
	        this.callback = callback;
	    }
	
	};
	
	module.exports = new Loop();

/***/ },
/* 64 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	
	var utils = __webpack_require__(38),
	    maxElapsed = 33,
	    Timer = function Timer() {
	    this.elapsed = 16.7;
	    this.current = utils.currentTime();
	    this.update();
	};
	
	Timer.prototype = {
	    update: function update(framestamp) {
	        this.prev = this.current;
	        this.current = framestamp;
	        this.elapsed = Math.min(this.current - this.prev, maxElapsed);
	
	        return this.current;
	    },
	
	    getElapsed: function getElapsed() {
	        return this.elapsed;
	    },
	
	    clock: function clock() {
	        this.current = utils.currentTime();
	    }
	};
	
	module.exports = Timer;

/***/ },
/* 65 */
/***/ function(module, exports, __webpack_require__) {

	"use strict";
	/*
	    requestAnimationFrame polyfill
	    
	    For IE8/9 Flinstones
	
	    Taken from Paul Irish. We've stripped out cancelAnimationFrame checks because we don't fox with that
	    
	    http://paulirish.com/2011/requestanimationframe-for-smart-animating/
	    http://my.opera.com/emoller/blog/2011/12/20/requestanimationframe-for-smart-er-animating
	     
	    requestAnimationFrame polyfill by Erik Möller. fixes from Paul Irish and Tino Zijdel
	     
	    MIT license
	*/
	var tick,
	    lastTime = 0,
	    hasWindow = typeof window !== 'undefined';
	
	if (!hasWindow) {
	    // Load rAF shim
	    tick = function (callback) {
	        var currTime = new Date().getTime(),
	            timeToCall = Math.max(0, 16 - (currTime - lastTime)),
	            id = setTimeout(function () {
	            callback(currTime + timeToCall);
	        }, timeToCall);
	
	        lastTime = currTime + timeToCall;
	
	        return id;
	    };
	} else {
	    tick = window.requestAnimationFrame;
	}
	
	module.exports = tick;

/***/ }
/******/ ]);
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["webpack:///webpack/bootstrap 6a119f96c50646dbf354","webpack:///./src/load/global.js","webpack:///./src/load/module.js","webpack:///./src/popmotion.js","webpack:///./src/value-types/alpha.js","webpack:///./src/value-types/angle.js","webpack:///./src/value-types/px.js","webpack:///./src/value-types/hsl.js","webpack:///./src/value-types/rgb.js","webpack:///./src/value-types/hex.js","webpack:///./src/value-types/color.js","webpack:///./src/value-types/positions.js","webpack:///./src/value-types/dimensions.js","webpack:///./src/value-types/scale.js","webpack:///./src/value-types/shadow.js","webpack:///./src/value-types/complex.js","webpack:///./src/roles/attr/attrRole.js","webpack:///./src/roles/css/cssRole.js","webpack:///./src/roles/svg/svgRole.js","webpack:///./src/roles/path/drawPathRole.js","webpack:///./src/value-types/manager.js","webpack:///./src/actor/Actor.js","webpack:///./src/sequence/Sequence.js","webpack:///./src/input/Input.js","webpack:///./src/iterator/Iterator.js","webpack:///./src/process/Process.js","webpack:///./src/roles/Role.js","webpack:///./src/actions/tween/Easing.js","webpack:///./src/actions/Action.js","webpack:///./src/actions/Tween.js","webpack:///./src/actions/Simulate.js","webpack:///./src/actions/Track.js","webpack:///./src/inc/select-actor.js","webpack:///./src/inc/calc.js","webpack:///./src/value-types/manipulators/create-delimited.js","webpack:///./src/value-types/manipulators/get-color-values.js","webpack:///./src/value-types/manipulators/function-create.js","webpack:///./src/value-types/settings/default-props.js","webpack:///./src/value-types/settings/dictionary.js","webpack:///./src/inc/utils.js","webpack:///./src/value-types/manipulators/split-space-delimited.js","webpack:///./src/roles/css/build.js","webpack:///./src/roles/css/map.js","webpack:///./src/roles/css/type-map.js","webpack:///./src/roles/svg/build.js","webpack:///./src/roles/svg/type-map.js","webpack:///./src/roles/path/map.js","webpack:///./src/inc/Queue.js","webpack:///./src/inc/select-dom.js","webpack:///./src/actor/update.js","webpack:///./src/actor/value-operations.js","webpack:///./src/roles/defaultRole.js","webpack:///./src/inc/History.js","webpack:///./src/controls/Controls.js","webpack:///./src/actions/tween/preset-easing.js","webpack:///./src/actions/tween/TweenControls.js","webpack:///./src/actions/simulate/simulations.js","webpack:///./src/input/Pointer.js","webpack:///./src/process/manager.js","webpack:///./src/actions/tween/Bezier.js","webpack:///./src/value-types/manipulators/split-comma-delimited.js","webpack:///./src/value-types/manipulators/function-break.js","webpack:///./src/roles/css/transform-dictionary.js","webpack:///./src/actions/Watch.js","webpack:///./src/process/loop.js","webpack:///./src/process/timer.js","webpack:///./src/process/tick.js"],"names":[],"mappings":"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","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n/** WEBPACK FOOTER **\n ** webpack/bootstrap 6a119f96c50646dbf354\n **/","var popmotion = require('./module.js'),\n    UIref = window.ui;\n\nwindow.ui = window.popmotion = popmotion;\n\n/*\n    If noConflict is run, the original reference to window.UI is\n    restored and Popmotion is loaded to window.Popmotion\n*/\nwindow.ui.noConflict = function () {\n    window.ui = UIref;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/load/global.js\n **/","\"use strict\";\n\nvar popmotion = require('../popmotion');\n\n/*\n    Add optional custom value type support\n*/\npopmotion.addValueType({\n    alpha: require('../value-types/alpha'),\n    angle: require('../value-types/angle'),\n    px: require('../value-types/px'),\n    hsl: require('../value-types/hsl'),\n    rgb: require('../value-types/rgb'),\n    hex: require('../value-types/hex'),\n    color: require('../value-types/color'),\n    positions: require('../value-types/positions'),\n    dimensions: require('../value-types/dimensions'),\n    scale: require('../value-types/scale'),\n    shadow: require('../value-types/shadow'),\n    complex: require('../value-types/complex')\n});\n\n/*\n    Predefined roles\n*/\n\npopmotion.attr = require('../roles/attr/attrRole');\npopmotion.css = require('../roles/css/cssRole');\npopmotion.svg = require('../roles/svg/svgRole');\npopmotion.drawPath = require('../roles/path/drawPathRole');\n\nmodule.exports = popmotion;\n\n\n/** WEBPACK FOOTER **\n ** ./src/load/module.js\n **/","var valueTypeManager = require('./value-types/manager'),\n\n    Popmotion = {\n\n        Actor: require('./actor/Actor'),\n\n        Sequence: require('./sequence/Sequence'),\n\n        Input: require('./input/Input'),\n\n        Iterator: require('./iterator/Iterator'),\n\n        Process: require('./process/Process'),\n\n        Easing: require('./actions/tween/Easing'),\n\n        Role: require('./roles/Role'),\n\n        Action: require('./actions/Action'),\n        Tween: require('./actions/Tween'),\n        Simulate: require('./actions/Simulate'),\n        Track: require('./actions/Track'),\n\n        /*\n            Create an Iterator of Actors with selected dom elements\n        */\n        select: require('./inc/select-actor'),\n\n        addValueType: function () {\n            valueTypeManager.extend.apply(valueTypeManager, arguments);\n            return this;\n        },\n\n        calc: require('./inc/calc')\n    };\n\nmodule.exports = Popmotion;\n\n\n/** WEBPACK FOOTER **\n ** ./src/popmotion.js\n **/","module.exports = {\n    defaultProps: {\n        min: 0,\n        max: 1\n    }\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/alpha.js\n **/","module.exports = {\n    defaultProps: {\n        unit: 'deg'\n    }\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/angle.js\n **/","module.exports = {\n    defaultProps: {\n        unit: 'px'\n    }\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/px.js\n **/","\"use strict\";\n\nvar createDelimited = require('./manipulators/create-delimited'),\n    getColorValues = require('./manipulators/get-color-values'),\n    functionCreate = require('./manipulators/function-create'),\n    defaultProps = require('./settings/default-props'),\n    terms = require('./settings/dictionary').hsl;\n\nmodule.exports = {\n\n    defaultProps: {\n        Hue: {\n            min: 0,\n            max: 360\n        },\n        Saturation: defaultProps.percent,\n        Lightness: defaultProps.percent,\n        Alpha: defaultProps.opacity\n    },\n\n    test: function (value) {\n        return (value && value.indexOf('hsl') > -1);\n    },\n    \n    split: function (value) {\n        return getColorValues(value, terms);\n    },\n\n    combine: function (values) {\n        return functionCreate(createDelimited(values, terms, ', ', 2), 'hsla');\n    }\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/hsl.js\n **/","\"use strict\";\n\nvar createDelimited = require('./manipulators/create-delimited'),\n    getColorValues = require('./manipulators/get-color-values'),\n    functionCreate = require('./manipulators/function-create'),\n    defaultProps = require('./settings/default-props'),\n    colorDefaults = defaultProps.color,\n    terms = require('./settings/dictionary').colors;\n\nmodule.exports = {\n\n    defaultProps: {\n        Red: colorDefaults,\n        Green: colorDefaults,\n        Blue: colorDefaults,\n        Alpha: defaultProps.opacity\n    },\n\n    test: function (value) {\n        return (value && value.indexOf('rgb') > -1);\n    },\n    \n    split: function (value) {\n        return getColorValues(value, terms);\n    },\n\n    combine: function (values) {\n        return functionCreate(createDelimited(values, terms, ', ', 2), 'rgba');\n    }\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/rgb.js\n **/","\"use strict\";\n\nvar rgb = require('./rgb');\n\nmodule.exports = {\n\n    defaultProps: rgb.defaultProps,\n\n    test: function (value) {\n        return (value && value.indexOf('#') > -1);\n    },\n    \n    split: function (value) {\n        var r, g, b;\n\n        // If we have 6 characters, ie #FF0000\n        if (value.length > 4) {\n            r = value.substr(1, 2);\n            g = value.substr(3, 2);\n            b = value.substr(5, 2);\n\n        // Or we have 3 characters, ie #F00\n        } else {\n            r = value.substr(1, 1);\n            g = value.substr(2, 1);\n            b = value.substr(3, 1);\n            r += r;\n            g += g;\n            b += b;\n        }\n\n        return {\n            Red: parseInt(r, 16),\n            Green: parseInt(g, 16),\n            Blue: parseInt(b, 16),\n            Alpha: 1\n        };\n    },\n\n    combine: function (values) {\n        return rgb.combine(values);\n    }\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/hex.js\n **/","\"use strict\";\n\nvar utils = require('../inc/utils'),\n    rgb = require('./rgb'),\n    hsl = require('./hsl'),\n    hex = require('./hex'),\n    supported = [rgb, hsl, hex],\n    numSupported = 3,\n\n    runSupported = function (method, value) {\n        for (var i = 0; i < numSupported; i++) {\n            if (supported[i].test(value)) {\n                return supported[i][method](value);\n            }\n        }\n    };\n\nmodule.exports = {\n\n    defaultProps: utils.merge(rgb.defaultProps, hsl.defaultProps),\n\n    test: function (value) {\n        return rgb.test(value) || hex.test(value) || hsl.test(value);\n    },\n\n    split: function (value) {\n        return runSupported('split', value);\n    },\n\n    combine: function (values) {\n        return (values.Red !== undefined) ? rgb.combine(values) : hsl.combine(values);\n    }\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/color.js\n **/","\"use strict\";\n\nvar createDelimited = require('./manipulators/create-delimited'),\n    pxDefaults = require('./px').defaultProps,\n    splitSpaceDelimited = require('./manipulators/split-space-delimited'),\n    terms = require('./settings/dictionary').positions;\n\nmodule.exports = {\n\n    defaultProps: pxDefaults,\n        \n    /*\n        Split positions in format \"X Y Z\"\n        \n        @param [string]: Position values\n            \"20% 30% 0\" -> {20%, 30%, 0}\n            \"20% 30%\" -> {20%, 30%}\n            \"20%\" -> {20%, 20%}\n    */\n    split: function (value) {\n        var positions = splitSpaceDelimited(value),\n            numPositions = positions.length,\n            splitValue = {\n                X: positions[0],\n                Y: (numPositions > 1) ? positions[1] : positions[0]\n            };\n\n        if (numPositions > 2) {\n            splitValue.Z = positions[2];\n        }\n\n        return splitValue;\n    },\n\n    combine: function (values) {\n        return createDelimited(values, terms, ' ');\n    }\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/positions.js\n **/","\"use strict\";\n\nvar terms = require('./settings/dictionary').dimensions,\n    pxDefaults = require('./px').defaultProps,\n    createDelimited = require('./manipulators/create-delimited'),\n    splitSpaceDelimited = require('./manipulators/split-space-delimited');\n\nmodule.exports = {\n\n    defaultProps: pxDefaults,\n    \n    /*\n        Split dimensions in format \"Top Right Bottom Left\"\n        \n        @param [string]: Dimension values\n            \"20px 0 30px 40px\" -> {20px, 0, 30px, 40px}\n            \"20px 0 30px\" -> {20px, 0, 30px, 0}\n            \"20px 0\" -> {20px, 0, 20px, 0}\n            \"20px\" -> {20px, 20px, 20px, 20px}\n        \n        @return [object]: Object with T/R/B/L metrics\n    */\n    split: function (value) {\n        var dimensions = splitSpaceDelimited(value),\n            numDimensions = dimensions.length,\n            jumpBack = (numDimensions !== 1) ? 2 : 1,\n            i = 0,\n            j = 0,\n            splitValue = {};\n\n        for (; i < 4; i++) {\n            splitValue[terms[i]] = dimensions[j];\n\n            // Jump back (to start) counter if we've reached the end of our values\n            j++;\n            j = (j === numDimensions) ? j - jumpBack : j;\n        }\n\n        return splitValue;\n    },\n\n    combine: function (values) {\n        return createDelimited(values, terms, ' ');\n    }\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/dimensions.js\n **/","module.exports = {\n    defaultProps: {\n        init: 1\n    }\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/scale.js\n **/","\"use strict\";\n\nvar color = require('./color'),\n    utils = require('../inc/utils'),\n    pxDefaults = require('./px').defaultProps,\n    terms = require('./settings/dictionary').shadow,\n    splitSpaceDelimited = require('./manipulators/split-space-delimited'),\n    createDelimited = require('./manipulators/create-delimited'),\n    shadowTerms = terms.slice(0,4);\n\nmodule.exports = {\n\n    defaultProps: utils.merge(color.defaultProps, {\n        X: pxDefaults,\n        Y: pxDefaults,\n        Radius: pxDefaults,\n        Spread: pxDefaults\n    }),\n\n    /*\n        Split shadow properties \"X Y Radius Spread Color\"\n        \n        @param [string]: Shadow property\n        @return [object]\n    */\n    split: function (value) {\n        var bits = splitSpaceDelimited(value),\n            numBits = bits.length,\n            hasReachedColor = false,\n            colorProp = '',\n            thisBit,\n            i = 0,\n            splitValue = {};\n\n        for (; i < numBits; i++) {\n            thisBit = bits[i];\n\n            // If we've reached the color property, append to color string\n            if (hasReachedColor || color.test(thisBit)) {\n                hasReachedColor = true;\n                colorProp += thisBit;\n\n            } else {\n                splitValue[terms[i]] = thisBit;\n            }\n        }\n        \n        return utils.merge(splitValue, color.split(colorProp));\n    },\n\n    combine: function (values) {\n        return createDelimited(values, shadowTerms, ' ') + color.combine(values);\n    }\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/shadow.js\n **/","var utils = require('../inc/utils'),\n    each = utils.each,\n    floatRegex = /(-)?(\\d[\\d\\.]*)/g,\n\n    generateToken = function (key) {\n        return '${' + key + '}';\n    };\n\nmodule.exports = {\n    test: function (value) {\n        var matches = value.match(floatRegex);\n        return (utils.isArray(matches) && matches.length > 1);\n    },\n\n    template: function (value) {\n        var counter = 0;\n        return value.replace(floatRegex, () => generateToken(counter++));\n    },\n\n    split: function (value) {\n        var splitValue = {},\n            matches = value.match(floatRegex),\n            numMatches = matches.length;\n        \n        for (let i = 0; i < numMatches; i++) {\n            splitValue[i] = matches[i];\n        }\n\n        return splitValue;\n    },\n\n    combine: function (values, template) {\n        var combinedValue = template;\n\n        each(values, (key, value) => {\n            combinedValue = combinedValue.replace(generateToken(key), value);\n        });\n\n        return combinedValue;\n    }\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/complex.js\n **/","\"use strict\";\n\nvar Role = require('../Role');\nvar each = require('../../inc/utils').each;\n\nvar attrRole = new Role({\n    update: function (state) {\n        var actor = this;\n\n        each(state, function (key, value) {\n            attrRole.set(actor.element, key, value);\n        });\n    },\n\n    get: function (element, key) {\n        return element.getAttribute(key);\n    },\n\n    set: function (element, key, value) {\n        element.setAttribute(key, value);\n    }\n});\n\nmodule.exports = attrRole;\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/roles/attr/attrRole.js\n **/","\"use strict\";\n\nvar Role = require('../Role');\nvar build = require('./build');\nvar each = require('../../inc/utils').each;\n\nvar prefixes = ['Webkit','Moz','O','ms', ''];\nvar numPrefixes = prefixes.length;\nvar propertyNameCache = {};\nvar testElement;\n                    \n/*\n    Test style property for prefixed version\n    \n    @param [string]: Style property\n    @return [string]: Cached property name\n*/\nvar testPrefix = function (key) {\n        testElement = testElement || document.createElement('div');\n\n        if (propertyNameCache[key] === false) {\n            return false;\n        } else {\n            propertyNameCache[key] = false;\n        }\n\n        for (var i = 0; i < numPrefixes; i++) {\n            var prefix = prefixes[i],\n                prefixed = (prefix === '') ? key : prefix + key.charAt(0).toUpperCase() + key.slice(1);\n\n            if (prefixed in testElement.style) {\n                propertyNameCache[key] = prefixed;\n            }\n        }\n        \n        return propertyNameCache[key];\n    };\n\nvar cssRole = new Role({\n    _map: require('./map'),\n    _typeMap: require('./type-map'),\n\n    init: function () {\n        this._cssCache = {};\n    },\n\n    update: function (state) {\n        var actor = this;\n\n        each(build(state, actor._cssCache), function (key, value) {\n            cssRole.set(actor.element, key, value);\n        });\n    },\n\n    get: function (element, key) {\n        key = propertyNameCache[key] || testPrefix(key);\n\n        if (key) {\n            return window.getComputedStyle(element, null)[key];\n        }\n    },\n\n    set: function (element, key, value) {\n        key = propertyNameCache[key] || testPrefix(key);\n\n        if (key) {\n            element.style[key] = value;\n        }\n    }\n\n});\n\nmodule.exports = cssRole;\n\n\n/** WEBPACK FOOTER **\n ** ./src/roles/css/cssRole.js\n **/","\"use strict\";\n\nvar Role = require('../Role'),\n    attrRole = require('../attr/attrRole'),\n    build = require('./build'),\n    each = require('../../inc/utils').each;\n\nmodule.exports = new Role({\n    _map: require('../css/map'),\n    _typeMap: require('./type-map'),\n\n    start: function () {\n        var boundingBox = this.element.getBBox(),\n            values = this.values,\n            // TODO: Support px\n            transformOriginX = values.transformOriginX ? values.transformOriginX.current : 50,\n            transformOriginY = values.transformOriginY ? values.transformOriginY.current : 50,\n            origin = {\n                x: boundingBox.width * (transformOriginX / 100) + boundingBox.x,\n                y: boundingBox.height * (transformOriginY / 100) + boundingBox.y\n            };\n\n        this.svgOrigin = origin;\n    },\n\n    update: function (state) {\n        var actor = this;\n        each(build(state, this.svgOrigin), function (key, value) {\n            attrRole.set(actor.element, key, value);\n        });\n    }\n\n});\n\n\n/** WEBPACK FOOTER **\n ** ./src/roles/svg/svgRole.js\n **/","\"use strict\";\n\nvar Role = require('../Role');\nvar attrRole = require('../attr/attrRole');\nvar each = require('../../inc/utils').each;\n\n/*\n    Convert percentage to pixels\n    \n    @param [number]: Percentage of total length\n    @param [number]: Total length\n*/\nvar percentToPixels = function (percentage, length) {\n    return (parseFloat(percentage) / 100) * length + 'px';\n};\n\n/*\n    Create styles\n    \n    @param [object]: SVG Path properties\n    @param [object]: Length of path\n    @returns [object]: Key/value pairs of valid CSS properties\n*/\nvar createStyles = function (props, length) {\n    var hasDashArray = false,\n        dashArrayStyles = {\n            length: 0,\n            spacing: length + 'px'\n        },\n        styles = {};\n\n    each(props, function (key, value) {\n        key = SVGDrawPath._map[key] || key;\n\n        switch (key) {\n            case 'length':\n            case 'spacing':\n                hasDashArray = true;\n                dashArrayStyles[key] = percentToPixels(value, length);\n                break;\n            case 'offset':\n                styles['stroke-dashoffset'] = percentToPixels(-value, length);\n                break;\n            default:\n                styles[key] = value;\n        }\n    });\n\n    if (hasDashArray) {\n        styles['stroke-dasharray'] = dashArrayStyles.length + ' ' + dashArrayStyles.spacing;\n    }\n\n    return styles;\n};\n\n/*\n    Draw Path role\n*/\nvar SVGDrawPath = new Role({\n    _map: require('./map'),\n\n    _typeMap: {\n        stroke: 'color',\n        d: 'complex'\n    },\n\n    init: function () {\n        this.pathLength = this.element.getTotalLength();\n    },\n\n    /*\n        Update `path` styles and if `element` is present, set\n        x, y and rotation\n    */\n    update: function (state) {\n        attrRole.update.call(this, createStyles(state, this.pathLength));\n    }\n});\n\nmodule.exports = SVGDrawPath;\n\n\n/** WEBPACK FOOTER **\n ** ./src/roles/path/drawPathRole.js\n **/","var each = require('../inc/utils').each,\n\n    ValueTypeManager = function () {};\n\nValueTypeManager.prototype = {\n    extend: function (name, mod) {\n        var multiMods = (typeof name == 'object'),\n            mods = multiMods ? name : {};\n\n        // If we just have one module, coerce\n        if (!multiMods) {\n            mods[name] = mod;\n        }\n\n        each(mods, (key, thisMod) => {\n            this[key] = thisMod;\n        });\n    },\n\n    defaultProps: function (type, key) {\n        var valueType = this[type],\n            defaultProps = (valueType.defaultProps) ? valueType.defaultProps[key] || valueType.defaultProps : {};\n\n        return defaultProps;\n    },\n\n    test: function (value) {\n        var type = false;\n\n        each(this, function (key, mod) {\n            if (mod.test && mod.test(value)) {\n                type = key;\n            }\n        });\n\n        return type;\n    }\n};\n\nmodule.exports = new ValueTypeManager();\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/manager.js\n **/","var Process = require('../process/Process'),\n    Queue = require('../inc/Queue'),\n    utils = require('../inc/utils'),\n    select = require('../inc/select-dom'),\n    update = require('./update'),\n    valueOps = require('./value-operations'),\n\n    /*\n        Role imports\n    */\n    defaultRole = require('../roles/defaultRole'),\n    cssRole = require('../roles/css/cssRole'),\n    svgRole = require('../roles/svg/svgRole'),\n    drawPathRole = require('../roles/path/drawPathRole'),\n\n    Action = require('../actions/Action'),\n    each = utils.each;\n\nclass Actor {\n\n    /*\n        @param [object]\n    */\n    constructor(opts = {}) {\n        var props = utils.isString(opts) ? { element: opts } : opts;\n\n        this.values = {};\n        this.state = { values: {} };\n        this.queue = new Queue();\n        this.process = new Process(this, update);\n        this.activeActions = {};\n        this.numActive = 0;\n        this.actionCounter = 0;\n        this.activeValues = [];\n        this.activeParents = [];\n        this.isActive = false;\n\n        // Get actual elements if this is a selector\n        if (utils.isString(props.element)) {\n            props.element = select(props.element)[0];\n        }\n\n        this.assignRoles(props.element, props.as, true);\n        this.set(props);\n        this.initRoles();\n    }\n\n    /*\n        Set Actor properties and values\n\n        @param [object]\n        @returns [Actor]\n    */\n    set(opts) {\n        each(opts, (key, value) => {\n            if (key !== 'values' && key !== 'action') {\n                this[key] = value;\n            }\n        });\n\n        if (opts && opts.values) {\n            this.values = valueOps.process(this.values, opts.values, opts, 'current', this);\n        }\n\n        // Check all active actions for any that can be removed\n        each(this.activeActions, (id, action) => {\n            let actionIsActive = false;\n\n            each(this.values, (key, value) => {\n                actionIsActive = (value.action === action) ? true : actionIsActive;\n            });\n\n            if (!actionIsActive) {\n                this.unbindAction(id);\n            }\n        });\n\n        return this;\n    }\n\n    /*\n        Bind Action-specific controls to Actor\n\n        @returns [Controls]\n    */\n    controls(action) {\n        var Controls = action.getControls();\n        return new Controls(this, action.getPlayable());\n    }\n\n    /*\n        Start a new Action\n\n        @param [Action || number]\n        @param [Input || event] (optional)\n        @param [boolean] (optional): defined `true` if we surpress making new queue\n        @returns [Controls]\n    */\n    start(toSet, input) {\n        let actionExists = utils.isNum(toSet),\n            action = (actionExists) ? this.getAction(toSet) : toSet.getPlayable(),\n            opts = action.getSet(),\n            surpressQueueClear = (arguments[arguments.length - 1] === false);\n\n        opts.action = action;\n\n        this.set(opts);\n\n        if (input) {\n            action.bindInput(input);\n        }\n\n        if (!surpressQueueClear) {\n            this.queue.clear();\n        }\n\n        // Fire all Role onStarts if not already active\n        if (!this.isActive) {\n            let numRoles = this.roles.length;\n            for (let i = 0; i < numRoles; i++) {\n                let role = this.roles[i];\n                if (role.start) {\n                    role.start.call(this, this);\n                }\n            }\n        }\n\n        // Fire new action onStart\n        if (!action.isActive && action.onStart) {\n            action.onStart.call(this, this, action);\n        }\n\n        this.activate();\n\n        if (!actionExists) {\n            let Controls = action.getControls();\n            return new Controls(this, action, true);\n        }\n    }\n\n    /*\n        Pause all active Actions\n\n        @param [int] (optional)\n        @returns [Actor]\n    */\n    pause() {\n        this.isActive = false;\n        each(this.activeActions, (id, action) => action.deactivate());\n        this.process.stop();\n        return this;\n    }\n\n    /*\n        Resume all active Actions\n\n        @param [int] (optional)\n        @returns [Actor];\n    */\n    resume() {\n        this.isActive = true;\n        each(this.activeActions, (id, action) => action.activate());\n        this.process.start();\n        return this;\n    }\n\n    /*\n        Stop all active Actions\n\n        @param [int] (optional)\n        @returns [Actor]\n    */\n    stop() {\n        this.pause();\n        each(this.activeActions, (id) => this.unbindAction(id));\n        return this;\n    }\n\n    /*\n        Toggle all active Actions\n\n        @param [int] (optional)\n        @returns [Actor]\n    */\n    toggle() {\n        return this.isActive ? this.pause() : this.resume();\n    }\n\n    /*\n        Syncs `element` with current properties\n\n        @returns [Actor]\n    */\n    sync() {\n        this.start(new Action({ values: this.values }));\n        return this;\n    }\n\n    /*\n        Add a new Action to the queue\n    */\n    then() {\n        this.queue.add.apply(this.queue, arguments);\n        return this;\n    }\n\n    /*\n        Execute next in queue\n    */\n    next() {\n        var next = this.queue.next();\n\n        if (next) {\n            if (utils.isFunc(next[0])) {\n                next[0]();\n                this.next();\n            // Or this is an action\n            } else {\n                next.push(false);\n                this.start.apply(this, next);\n            }\n        } else {\n            this.stop();\n        }\n\n        return this;\n    }\n\n    /*\n        Assign Roles based on element and manually provided props\n\n        @param [object]: Element\n        @param [Role || array]\n        @param [boolean] (optional)\n    */\n    assignRoles(element, manualRoles, surpressInit) {\n        // All Actors get a default Role that handles user callbacks\n        this.roles = [ defaultRole ];\n\n        // Auto-assign if no manually-set Roles\n        if (!manualRoles && element) {\n            this.autoAssignRoles(element);\n\n        // Or manually set if provided\n        } else if (manualRoles) {\n            if (utils.isArray(manualRoles)) {\n                this.roles.push.apply(this.roles, manualRoles);\n            } else {\n                this.roles.push(manualRoles);\n            }\n        }\n\n        if (!surpressInit) {\n            this.initRoles();\n        }\n    }\n\n    /*\n        Automatically assign Roles based on element, designed\n        to be extended\n\n        @param [object]: Element\n    */\n    autoAssignRoles(element) {\n        // Add CSS role if HTMLElement\n        if (element instanceof HTMLElement || element.tagName === 'svg') {\n            this.roles.push(cssRole);\n\n        // Add SVG role if SVG element\n        } else if (element instanceof SVGElement) {\n            this.roles.push(svgRole);\n\n            // Add Draw Path role if path element\n            if (element.tagName === 'path') {\n                this.roles.push(drawPathRole);\n            }\n        }\n    }\n\n    /*\n        Fire init callbacks\n    */\n    initRoles() {\n        // Fire init callback\n        this.roles.forEach((role) => {\n            if (role.init) {\n                role.init.call(this, this);\n            }\n        });\n    }\n\n    activate() {\n        if (!this.isActive) {\n            this.isActive = true;\n            this.firstFrame = true;\n            this.process.start();\n        }\n    }\n\n    /*\n        Bind Action and return its table id\n\n        @param [Action]\n        @returns [int]\n    */\n    bindAction(action, id) {\n        if (id === undefined) {\n            id = this.actionCounter++;\n        }\n\n        if (!this.hasAction(id)) {\n            this.activeActions[id] = action;\n            this.numActive++;\n        }\n\n        return id;\n    }\n\n    unbindAction(id) {\n        if (this.activeActions.hasOwnProperty(id)) {\n            this.numActive--;\n            delete this.activeActions[id];\n        }\n\n        if (!this.numActive) {\n            this.pause();\n        }\n    }\n\n    getAction(id) {\n        return this.activeActions[id];\n    }\n\n    hasAction(id) {\n        return (this.getAction(id) !== undefined);\n    }\n\n    /*\n        Update processing order\n        \n        @param [string]\n        @param [boolean]\n        @param [boolean]\n    */\n    updateOrder(key, moveToBack, hasChildren) {\n        var order = (!hasChildren) ? this.activeValues : this.activeParents,\n            position = order.indexOf(key);\n\n        // If key isn't list or moveToBack is set to true, add key\n        if (position === -1 || moveToBack) {\n            order.push(key);\n\n            // If key already exists, remove\n            if (position > -1) {\n                order.splice(position, 1);\n            }\n        }\n    }\n\n    // [boolean]: Is this Actor active?\n    get isActive() {\n        return this._isActive;\n    }\n\n    // Set hasChanged to true is this is now active\n    set isActive(status) {\n        if (status === true) {\n            this.hasChanged = status;\n        }\n\n        this._isActive = status;\n    }\n}\n\nmodule.exports = Actor;\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/actor/Actor.js\n **/","var Actor = require('../actor/Actor');\nvar Tween = require('../actions/Tween');\nvar utils = require('../inc/utils');\nvar calcRelative = require('../inc/calc').relativeValue;\n\nvar timeline = new Tween({\n    ease: 'linear',\n    values: {\n        playhead: 0\n    }\n});\n\nfunction checkActions({ playhead }, sequence) {\n    var i = sequence.check.length;\n\n    while (i--) {\n        let toCheck = sequence.check[i];\n\n        if (playhead >= toCheck.timestamp) {\n            toCheck.callback();\n            sequence.check.splice(i, 1);\n        }\n    }\n}\n\nfunction generateCallback(actor, action) {\n    var callback;\n\n    if (actor.each) {\n        callback = () => {\n            actor.each(action);\n        };\n    } else {\n        callback = () => {\n            actor.start(action);\n        };\n    }\n\n    return callback;\n}\n\nclass Sequence extends Actor {\n\n    constructor() {\n        super({\n            check: [],\n            sequence: [],\n            duration: 0,\n            currentTimestamp: 0,\n            prevActionEnd: 0,\n            onUpdate: checkActions\n        });\n    }\n\n    do(actor, action) {\n        var isCallback = utils.isFunc(actor);\n\n        this.sequence.push({\n            timestamp: this.currentTimestamp,\n            callback: isCallback ? actor : generateCallback(actor, action)\n        });\n\n        if (action && action.duration) {\n            this.prevActionEnd = this.currentTimestamp + action.duration;\n        }\n\n        return this;\n    }\n\n    stagger(iterator, action, staggerProps) {\n        var numItems = iterator.members.length,\n            interval = utils.isNum(staggerProps) ? staggerProps : staggerProps.interval || 100,\n            duration = action.duration ? action.duration : 0;\n\n        this.do(iterator, () => {\n            iterator.stagger(action, staggerProps);\n        });\n\n        this.prevActionEnd = this.currentTimestamp + duration + (interval * numItems);\n\n        return this;\n    }\n\n    at(timestamp) {\n        if (utils.isString(timestamp)) {\n            timestamp = calcRelative(this.currentTimestamp, timestamp);\n        }\n\n        this.currentTimestamp = timestamp;\n        this.duration = Math.max(this.currentTimestamp, this.duration);\n        return this;\n    }\n\n    then(offset = \"+=0\") {\n        this.at(calcRelative(this.prevActionEnd, offset));\n        return this;\n    }\n\n    start() {\n        super.start(timeline.extend({\n            duration: this.duration,\n            values: {\n                playhead: {\n                    current: 0,\n                    to: this.duration\n                }\n            }\n        }));\n\n        return this;\n    }\n\n    onStart() {\n        this.check = this.sequence.slice();\n    }\n\n    clear() {\n        this.sequence = [];\n        this.duration = this.currentTimestamp = this.prevActionEnd = 0;\n        return this;\n    }\n}\n\nmodule.exports = Sequence;\n\n\n/** WEBPACK FOOTER **\n ** ./src/sequence/Sequence.js\n **/","/*\n    Input controller\n*/\n\"use strict\";\n\nvar calc = require('../inc/calc.js'),\n    utils = require('../inc/utils.js'),\n    History = require('../inc/History.js'),\n\n    /*\n        Input constructor\n        \n            Syntax\n                newInput(name, value[, poll])\n                    @param [string]: Name of to track\n                    @param [number]: Initial value\n                    @param [function] (optional): Function to poll Input data\n                    \n                newInput(props[, poll])\n                    @param [object]: Object of values\n                    @param [function] (optional): Function to poll Input data\n\n        @return [Input]\n    */\n    Input = function () {\n        var pollPos = arguments.length - 1;\n\n        this.current = {};\n        this.offset = {};\n        this.velocity = {};\n        this.history = new History();\n        this.update(arguments[0], arguments[1]);\n        \n        if (utils.isFunc(arguments[pollPos])) {\n            this.poll = arguments[pollPos];\n        }\n    };\n\nInput.prototype = {\n    \n    // [number]: Number of frames of inactivity before velocity is turned to 0\n    maxInactiveFrames: 2,\n    \n    // [number]: Number of frames input hasn't been updated\n    inactiveFrames: 0,\n    \n    /*\n        Get latest input values\n        \n        @param [string] (optional): Name of specific property to return\n        @return [object || number]: Latest input values or, if specified, single value\n    */\n    get: function (prop) {\n        var latest = this.history.get(),\n            val = (prop !== undefined) ? latest[prop] : latest;\n        return val;\n    },\n\n    /*\n        Update the input values\n        \n        Syntax\n            input.update(name, value)\n                @param [string]: Name of to track\n                @param [number]: Initial value\n                \n            input.update(props)\n                @param [object]: Object of values\n                \n        @return [Input]\n    */\n    update: function (arg0, arg1) {\n        var values = {};\n\n        if (utils.isNum(arg1)) {\n            values[arg0] = arg1;\n        } else {\n            values = arg0;\n        }\n\n        this.history.add(utils.merge(this.current, values));\n        \n        return this;\n    },\n    \n    /*\n        Check for input movement and update pointer object's properties\n        \n        @param [number]: Timestamp of frame\n        @return [Input]\n    */\n    onFrame: function (timestamp) {\n        var latest, hasChanged;\n        \n        // Check provided timestamp against lastFrame timestamp and return input has already been updated\n        if (timestamp === this.lastFrame) {\n            return;\n        }\n        \n        latest = (this.poll) ? this.poll() : this.history.get();\n        hasChanged = utils.hasChanged(this.current, latest);\n\n        // If input has changed between frames  \n        if (hasChanged) {\n            this.velocity = calc.offset(this.current, latest);\n            this.current = latest;\n            this.inactiveFrames = 0;\n\n        // Or it hasn't moved and our frame limit has been reached\n        } else if (this.inactiveFrames >= this.maxInactiveFrames) {\n            this.velocity = calc.offset(this.current, this.current);\n        \n        // Or input hasn't changed\n        } else {\n            this.inactiveFrames++;\n        }\n        \n        this.lastFrame = timestamp;\n        \n        return this;\n    }\n};\n\nmodule.exports = Input;\n\n\n/** WEBPACK FOOTER **\n ** ./src/input/Input.js\n **/","var Actor = require('../actor/Actor'),\n    Tween = require('../actions/Tween'),\n    utils = require('../inc/utils');\n\nconst DEFAULT_STAGGER_EASE = 'linear';\n\nfunction generateCallback(method, ...args) {\n    var callback = method;\n\n    if (utils.isString(method)) {\n        callback = (member) => member[method](...args);\n    } else if (!utils.isFunc(method)) {\n        callback = (member) => member.start(method, ...args);\n    }\n\n    return callback;\n}\n\nclass Iterator {\n    constructor(members) {\n        this.clear();\n\n        if (members) {\n            this.add(members);\n        }\n\n        this._stagger = new Actor();\n    }\n\n    add(members) {\n        this.members = this.members.concat(members);\n        return this;\n    }\n\n    clear() {\n        this.members = [];\n        return this;\n    }\n\n    each(method, ...args) {\n        var callback = generateCallback(method, ...args);\n        this.members.forEach(callback);\n        return this;\n    }\n\n    eachIntoNew(method, ...args) {\n        var callback = generateCallback(method, ...args),\n            newIterator = new Iterator();\n\n        this.members.forEach((member) => newIterator.add(callback(member)));\n\n        return newIterator;\n    }\n\n    stagger(method, props, ...args) {\n        var tempMembers = utils.copyArray(this.members),\n            numMembers = tempMembers.length,\n            propsIsInterval = utils.isNum(props),\n            interval = propsIsInterval ? props : props.interval || 100,\n            staggerProps = {},\n            i = -1,\n            callback = generateCallback(method, ...args);\n\n        staggerProps.values = {\n            i: {\n                current: -0.6,\n                duration: interval * numMembers,\n                ease: propsIsInterval ? DEFAULT_STAGGER_EASE : props.ease || DEFAULT_STAGGER_EASE,\n                round: true,\n                to: numMembers - 0.6\n            }\n        };\n\n        staggerProps.onComplete = propsIsInterval ? undefined : props.onComplete;\n\n        staggerProps.onUpdate = (output) => {\n            var newIndex = output.i,\n                gapIndex = i + 1;\n\n            // If our new index is only one more than the previous index, fire immedietly\n            if (newIndex === i + 1) {\n                callback(tempMembers[gapIndex], gapIndex);\n\n            // Or loop through the distance to fire all indecies. Increase delay.\n            } else {\n                for (; gapIndex <= newIndex; gapIndex++) {\n                    callback(tempMembers[gapIndex], gapIndex);\n                }\n            }\n\n            i = newIndex;\n        };\n\n        this._stagger.start(new Tween(staggerProps));\n\n        return this;\n    }\n\n    /*\n        Array manipulation\n    */\n    reverse() {\n        this.members.reverse();\n        return this;\n    }\n}\n\nmodule.exports = Iterator;\n\n\n/** WEBPACK FOOTER **\n ** ./src/iterator/Iterator.js\n **/","\"use strict\";\n\nvar manager = require('./manager'),\n\n    /*\n        Process constructor\n        \n        Syntax\n            var process = new Process(scope, callback);\n            var process = new Process(callback);\n    */\n    Process = function (scope, callback) {\n        var hasScope = (callback !== undefined);\n\n        this.callback = hasScope ? callback : scope;\n        this.scope = hasScope ? scope : this;\n        this.id = manager.register();\n\n        // [boolean]: Is this process currently active?\n        this.isActive = false;\n    };\n\nProcess.prototype = {\n    /*\n        Fire callback\n        \n        @param [timestamp]: Timestamp of currently-executed frame\n        @param [number]: Time since last frame\n    */\n    fire: function (timestamp, elapsed) {\n        this.callback.call(this.scope, timestamp, elapsed);\n        \n        // If we're running at an interval, deactivate again\n        if (this.isInterval) {\n            this.deactivate();\n        }\n\n        return this;\n    },\n    \n    /*\n        Start process\n        \n        @param [int]: Duration of process in ms, 0 if indefinite\n        @return [this]\n    */\n    start: function (duration) {\n        var self = this;\n\n        this.reset();\n        this.activate();\n        \n        if (duration) {\n            this.stopTimer = setTimeout(function () {\n                self.stop();\n            }, duration);\n            \n            this.isStopTimerActive = true;\n        }\n\n        return this;\n    },\n    \n    /*\n        Stop process\n        \n        @return [this]\n    */\n    stop: function () {\n        this.reset();\n        this.deactivate();\n        \n        return this;\n    },\n    \n    /*\n        Activate process\n        \n        @return [this]\n    */\n    activate: function () {\n        this.isActive = true;\n        manager.activate(this, this.id);\n\n        return this;\n    },\n    \n    /*\n        Deactivate process\n        \n        @return [this]\n    */\n    deactivate: function () {\n        this.isActive = false;\n        manager.deactivate(this.id);\n        \n        return this;\n    },\n    \n    /*\n        Fire process every x ms\n        \n        @param [int]: Number of ms to wait between refiring process.\n        @return [this]\n    */\n    every: function (interval) {\n        var self = this;\n\n        this.reset();\n\n        this.isInterval = true;\n\n        this.intervalTimer = setInterval(function () {\n            self.activate();\n        }, interval);\n        \n        this.isIntervalTimeActive = true;\n        \n        return this;\n    },\n    \n    /*\n        Clear all timers\n        \n        @param \n    */\n    reset: function () {\n        this.isInterval = false;\n        \n        if (this.isStopTimerActive) {\n            clearTimeout(this.stopTimer);\n        }\n        \n        if (this.isIntervalTimeActive) {\n            clearInterval(this.intervalTimer);\n        }\n        \n        return this;\n    }\n};\n\nmodule.exports = Process;\n\n\n/** WEBPACK FOOTER **\n ** ./src/process/Process.js\n **/","var utils = require('../inc/utils');\nvar each = utils.each;\n\n/*\n    Role class constructor\n\n    @param [object]: Optional methods and props to add:\n        name [string]:      Name of generated getter/setter method on Actor\n        _map [object]:      Map Actor values to these values for this Role\n        _typeMap [object]:  Map values to value types\n        init [function]:    Callback to run when this Role is added to an Actor\n        start [function]:   Callback to run when host Actor starts an action\n        complete [function]: Callback to run when action completes\n        frame [function]:   Callback to fire once per frame\n        update [function]:  Callback to fire when values change\n        get [function]:     Read value from actual element\n        set [function]:     Set value on actual element\n*/\nvar Role = function (methods) {\n    var role = function (element, opts, prop) {\n        var typeOfOpts = typeof opts;\n\n        // Set single, if this is a string and we have a property\n        if (typeOfOpts === 'string' && prop) {\n            role.set(element, opts, prop);\n        \n        // Set multi, if this is an object\n        } else if (typeOfOpts === 'object') {\n            each(opts, (key, value) => {\n                role.set(element, key, value);\n            });\n        \n        // Or this is a get if we have a string and no props\n        } else {\n            return role.get(element, opts);\n        }\n\n        return role;\n    };\n\n    role._map = {};\n\n    each(methods, function (name, method) {\n        role[name] = (!utils.isObj(method)) ? method : utils.copy(method);\n    });\n\n\n    /*\n        Map value keys or generate new Role with updated map\n\n        Getter:\n            @param [string]: Key to map\n            @return [string]: Mapped key, or key if no mapped key found\n\n        Setter: \n            @param [object]: Map of Actor keys -> Role keys\n            @return [Role]: New Role with unique map\n    */\n    role.map = function (values) {\n        // If this is a string, get mapped value\n        // Otherwise this is a map, duplicated role with updated map\n        return (utils.isString(values)) ? this._map[values] || values : createRole(this, values);\n    };\n\n    return role;\n};\n\n/*\n    Create a new role\n\n    @param [object]: Optional methods and props to add\n    @param [valuesToMap]: Override existing map with these values\n    @return [Role]: New Role\n*/\nvar createRole = function (methods, values) {\n    var newRole = new Role(methods);\n\n    each(values, function (key, value) {\n        newRole._map[key] = value;\n    });\n\n    return newRole;\n};\n\nmodule.exports = Role;\n\n\n/** WEBPACK FOOTER **\n ** ./src/roles/Role.js\n **/","var Bezier = require('./Bezier'),\n\n    /*\n        Mirror easing\n        \n        Mirrors the provided easing function, used here for mirroring an\n        easeIn into an easeInOut\n        \n        @param [number]: Progress, from 0 - 1, of current shift\n        @param [function]: The easing function to mirror\n        @returns [number]: The easing-adjusted delta\n    */\n    mirrorEasing = function (progress, method) {\n        return (progress <= 0.5) ? method(2 * progress) / 2 : (2 - method(2 * (1 - progress))) / 2;\n    },\n            \n    /*\n        Reverse easing\n        \n        Reverses the output of the provided easing function, used for flipping easeIn\n        curve to an easeOut.\n        \n        @param [number]: Progress, from 0 - 1, of current shift\n        @param [function]: The easing function to reverse\n        @returns [number]: The easing-adjusted delta\n    */\n    reverseEasing = function (progress, method) {\n        return 1 - method(1 - progress);\n    };\n\n/*\n    Easing class\n\n    If provided easing function, returns easing function with \n    in/out/inOut variations\n\n    If provided four arguments, returns new Bezier class instead.\n*/\nvar Easing = function (x1, y1, x2, y2) {\n    var method = x1,\n        easingFunction;\n\n    // If this is a bezier curve, return a bezier function\n    if (arguments.length > 1) {\n        easingFunction = new Bezier(x1, y1, x2, y2);\n\n    } else {\n        easingFunction = function (progress) {\n            return method(progress);\n        };\n\n        easingFunction.in = function (progress) {\n            return method(progress);\n        };\n\n        easingFunction.out = function (progress) {\n            return reverseEasing(progress, method);\n        };\n\n        easingFunction.inOut = function (progress) {\n            return mirrorEasing(progress, method);\n        };\n    }\n\n    return easingFunction;\n};\n\nmodule.exports = Easing;\n\n\n/** WEBPACK FOOTER **\n ** ./src/actions/tween/Easing.js\n **/","let calc = require('../inc/calc'),\n    utils = require('../inc/utils'),\n    each = utils.each,\n    Controls = require('../controls/Controls');\n\nconst DEFAULT_PROP = 'current';\nconst PRIVATE = ['onStart', 'onFrame', 'onUpdate', 'onComplete'];\n\nclass Action {\n    constructor(props) {\n        var action = this;\n\n        utils.each(this.getDefaultProps(), function (key, value) {\n            action[key] = value;\n        });\n\n        this.values = {};\n        this.set(props, this.getDefaultValueProp());\n    }\n\n    set(props = {}, defaultProp = DEFAULT_PROP) {\n        each(props, (key, prop) => {\n            if (key !== 'values') {\n                this[key] = prop;\n            }\n        });\n\n        // Merge values\n        if (props.values) {\n            let currentValues = this.values,\n                values = props.values;\n\n            each(values, (key, value) => {\n                let existingValue = currentValues[key],\n                    newValue = {};\n                \n                if (utils.isObj(value)) {\n                    newValue = value;\n                } else {\n                    newValue[defaultProp] = value;\n                }\n\n                currentValues[key] = existingValue ? utils.merge(existingValue, newValue) : newValue;\n            });\n        }\n\n        return this;\n    }\n\n    process(actor, value) {\n        return value.current;\n    }\n\n   /*\n        Has Action ended?\n        \n        Returns true to end immedietly\n        \n        @return [boolean]: true\n    */\n    hasEnded() {\n        return true;\n    }\n        \n    limit(output, value) {\n        var restricted = calc.restricted(output, value.min, value.max),\n            escapeAmp = value.escapeAmp !== undefined ? value.escapeAmp : 0;\n        return restricted + ((output - restricted) * escapeAmp);\n    }\n\n    getControls() {\n        return Controls;\n    }\n\n    getDefaultProps() {\n        return {};\n    }\n\n    getDefaultValue() {\n        return {};\n    }\n\n    getDefaultValueProp() {\n        return DEFAULT_PROP;\n    }\n\n    getSet() {\n        var set = { values: this.values };\n\n        each(this, (key, prop) => {\n            if (this.hasOwnProperty(key) && PRIVATE.indexOf(key) === -1) {\n                set[key] = prop;\n            }\n        });\n\n        return set;\n    }\n\n    extend(props) {\n        return new this.constructor(utils.merge(this, props), this.getDefaultValueProp());\n    }\n\n    getPlayable() {\n        return this.extend();\n    }\n\n    activate() {\n        this.isActive = true;\n        return this;\n    }\n\n    deactivate() {\n        this.isActive = false;\n        return this;\n    }\n}\n\nmodule.exports = Action;\n\n\n/** WEBPACK FOOTER **\n ** ./src/actions/Action.js\n **/","let Action = require('./Action'),\n    calc = require('../inc/calc'),\n    utils = require('../inc/utils'),\n    each = utils.each,\n    presetEasing = require('./tween/preset-easing'),\n    valueOps = require('../actor/value-operations'),\n    TweenControls = require('./tween/TweenControls'),\n\n    nextSteps = {\n        loop: 'restart',\n        yoyo: 'reverse',\n        flip: 'flipValues'\n    },\n\n    /*\n        Ease value within ranged parameters\n        \n        @param [number]: Progress between 0 and 1\n        @param [number]: Value of 0 progress\n        @param [number]: Value of 1 progress\n        @param [string || function]: Name of preset easing\n            to use or generated easing function\n        @return [number]: Value of eased progress in range\n    */  \n    ease = function (progress, from, to, ease) {\n        var progressLimited = calc.restricted(progress, 0, 1),\n            easingFunction = utils.isString(ease) ? presetEasing[ease] : ease;\n\n        return calc.valueEased(progressLimited, from, to, easingFunction);\n    };\n\nconst COUNT = 'count';\n\nclass Tween extends Action {\n    getControls() {\n        return TweenControls;\n    }\n    \n    getDefaultProps() {\n        return {\n            delay: 0,\n            dilate: 1,\n            duration: 300,\n            loop: false,\n            yoyo: false,\n            flip: false,\n            playDirection: 1,\n            ended: true,\n            elapsed: 0\n        };\n    }\n\n    getDefaultValue() {\n        return {\n            delay: 0,\n            duration: 300,\n            ease: 'easeOut',\n            stagger: 0,\n            steps: 0,\n            to: 0,\n            round: false\n        };\n    }\n\n    getDefaultValueProp() {\n        return 'to';\n    }\n\n    /*\n        Update Action elapsed time\n        \n        @param [object]: Action properties\n        @param [number]: Timestamp of current frame\n    */\n    onFrameStart(actor, frameDuration) {\n        this.elapsed = this.elapsed || 0;\n\n        if (frameDuration) {\n            this.elapsed += (frameDuration * actor.dilate) * this.playDirection;\n            this.ended = true;\n        }\n    }\n\n    /*\n        Calculate progress of value based on time elapsed,\n        value delay/duration/stagger properties\n\n        @param [Actor]\n        @param [object]: Value state and properties\n        @return [number]: Calculated value\n    */\n    process(actor, value) {\n        var target = value.to,\n            progressTarget = (this.playDirection === 1) ? 1 : 0,\n            newValue = value.current,\n            progress;\n\n        // If this value has a to property, otherwise we just return current value\n        if (target !== undefined) {\n            progress = calc.restricted(calc.progress(this.elapsed - value.delay, value.duration) - value.stagger, 0, 1);\n\n            // Mark Action as NOT ended if still in progress\n            if (progress !== progressTarget) {\n                this.ended = false;\n            }\n\n            // Step progress if we're stepping\n            if (value.steps) {\n                progress = utils.stepProgress(progress, value.steps);\n            }\n\n            // Ease value\n            newValue = ease(progress, value.origin, target, value.ease);\n        }\n\n        return newValue;\n    }\n\n    /*\n        If this tween has ended, check if we loop/yoyo/flip\n        \n        @return [boolean]: Has this tween really really ended?\n    */\n    hasEnded(actor) {\n        if (this.ended) {\n            each(nextSteps, (name, methodName) => {\n                if (this.checkNextStep(actor, name, this[methodName])) {\n                    this.ended = false;\n                    actor.hasChanged = true;\n                    return false;\n                }\n            });\n        }\n\n        return this.ended;\n    }\n\n    checkNextStep(actor, name, method) {\n        var stepTaken = false,\n            step = this[name],\n            count = this[name + COUNT] || 0,\n            forever = (step === true);\n\n        if (forever || utils.isNum(step)) {\n            ++count;\n            this[name + COUNT] = count;\n\n            if (forever || count <= step) {\n                method.call(this, actor);\n                stepTaken = true;\n            }\n        }\n\n        return stepTaken;\n    }\n\n    flipValues(actor) {\n        var actorValues = actor.values;\n        this.elapsed = this.duration - this.elapsed;\n\n        each(this.values, (key) => {\n            let value = actorValues[key];\n\n            if (value.children) {\n                each(value.children, (childKey) => {\n                    valueOps.flip(actorValues[key + childKey]);\n                });\n            }\n\n            valueOps.flip(value);\n        });\n    }\n\n    reverse() {\n        this.playDirection *= -1;\n    }\n\n    restart() {\n        this.elapsed = (this.playDirection === 1) ? 0 : this.duration;\n        this.started = utils.currentTime();\n    }\n}\n\nmodule.exports = Tween;\n\n\n/** WEBPACK FOOTER **\n ** ./src/actions/Tween.js\n **/","let Action = require('./Action'),\n    calc = require('../inc/calc'),\n    utils = require('../inc/utils'),\n    simulations = require('./simulate/simulations');\n\nconst DEFAULT_PROP = 'velocity';\n\nclass Simulate extends Action {\n    constructor(...args) {\n        super(...args);\n        this.calculatesVelocity = true;\n        this.inactiveFrames = 0;\n    }\n\n    getDefaultProps() {\n        return {\n            maxInactiveFrames: 3\n        };\n    }\n\n    getDefaultValue() {\n        return {\n            // [string]: Simulation to .run\n            simulate: DEFAULT_PROP,\n            \n            // [number]: Deceleration to apply to value, in units per second\n            deceleration: 0,\n            \n            // [number]: Acceleration to apply to value, in units per second\n            acceleration: 0,\n            \n            // [number]: Factor to multiply velocity by on bounce\n            bounce: 0,\n            \n            // [number]: Spring strength during 'string'\n            spring: 80,\n            \n            // [number]: Timeconstant of glide\n            timeConstant: 395,\n            \n            // [number]: Stop simulation under this speed\n            stopSpeed: 5,\n            \n            // [boolean]: Capture with spring physics on limit breach\n            capture: false,\n            \n            // [number]: Friction to apply per frame\n            friction: 0,\n            \n            to: 0,\n            round: false\n        };\n    }\n\n    getDefaultValueProp() {\n        return DEFAULT_PROP;\n    }\n\n    onStart() {\n        this.started = utils.currentTime();\n    }\n    \n    /*\n        Simulate the Value's per-frame movement\n        \n        @param [Actor]\n        @param [Value]: Current value\n        @param [string]: Key of current value\n        @param [number]: Duration of frame in ms\n        @return [number]: Calculated value\n    */\n    process(actor, value, key, timeSinceLastFrame) {\n        var simulate = value.simulate,\n            simulation = utils.isString(simulate) ? simulations[simulate] : simulate,\n            newVelocity = simulation ? simulation(value, timeSinceLastFrame, this.started) : 0;\n\n        value.velocity = (Math.abs(newVelocity) >= value.stopSpeed) ? newVelocity : 0;\n        return value.current + calc.speedPerFrame(value.velocity, timeSinceLastFrame);\n    }\n    \n    /*\n        Has this action ended?\n        \n        Use a framecounter to see if Action has changed in the last x frames\n        and declare ended if not\n        \n        @param [Actor]\n        @param [boolean]: Has Action changed?\n        @return [boolean]: Has Action ended?\n    */\n    hasEnded(actor, hasChanged) {\n        this.inactiveFrames = hasChanged ? 0 : this.inactiveFrames + 1;\n        return (this.inactiveFrames > actor.maxInactiveFrames);\n    }\n\n    /*\n        Limit output to value range, if any\n        \n        If velocity is at or more than range, and value has a bounce property,\n        run the bounce simulation\n        \n        @param [number]: Calculated output\n        @param [Value]: Current Value\n        @return [number]: Limit-adjusted output\n    */\n    limit(output, value) {\n        var isOutsideMax = (output >= value.max),\n            isOutsideMin = (output <= value.min),\n            isOutsideRange = isOutsideMax || isOutsideMin;\n\n        if (isOutsideRange) {\n            output = calc.restricted(output, value.min, value.max);\n\n            if (value.bounce) {\n                value.velocity = simulations.bounce(value);\n\n            } else if (value.capture) {\n                simulations.capture(value, isOutsideMax ? value.max : value.min);\n            }\n        }\n        \n        return output;\n    }\n}\n\nmodule.exports = Simulate;\n\n\n/** WEBPACK FOOTER **\n ** ./src/actions/Simulate.js\n **/","let Action = require('./Action'),\n    Pointer = require('../input/Pointer'),\n    calc = require('../inc/calc');\n\nfunction smooth(newValue, oldValue, duration, smoothing) {\n    return oldValue + (duration * (newValue - oldValue) / smoothing);\n}\n\nclass Track extends Action {\n    /*\n        Update input offset\n    */\n    onFrameStart(actor, frameDuration, framestamp) {\n        actor.state.input = this.input.onFrame(framestamp);\n        this.inputOffset = calc.offset(this.inputOrigin, this.input.current);\n        this.frameDuration = frameDuration;\n    }\n\n    /*\n        Move Value relative to Input movement\n        \n        @param [Value]: Current value\n        @param [string]: Key of current value\n        @return [number]: Calculated value\n    */\n    process(actor, value, key) {\n        var newValue = value.current,\n            unmapped = value.unmapped !== undefined ? value.unmapped : value.current;\n\n        if (this.inputOffset.hasOwnProperty(key)) {\n            newValue = (value.direct) ? this.input.current[key] : value.origin + (this.inputOffset[key] * value.amp);\n            newValue = (value.smooth) ? smooth(newValue, unmapped, this.frameDuration, value.smooth) : newValue;\n        }\n\n        return newValue;\n    }\n\n    /*\n        Has this Action ended? \n        \n        @return [boolean]: False to make user manually finish .track()\n    */\n    hasEnded() {\n        return false;\n    }\n\n    deactivate() {\n        super.deactivate();\n\n        if (this.input && this.input.stop) {\n            this.input.stop();\n        }\n\n        return this;\n    }\n\n    bindInput(input) {\n        this.input = (!input.current) ? new Pointer(input) : input;\n        this.inputOrigin = this.input.get();\n    }\n\n    getDefaultValue() {\n        return {\n            amp: 1,\n            direct: false,\n            smooth: 0\n        };\n    }\n}\n\nmodule.exports = Track;\n\n\n/** WEBPACK FOOTER **\n ** ./src/actions/Track.js\n **/","var Actor = require('../actor/Actor'),\n    Iterator = require('../iterator/Iterator'),\n    selectDom = require('./select-dom');\n\nconst SAVE_PROP = '__pm_actor_';\n\nmodule.exports = function (selector, opts = {}) {\n    var dom = selectDom(selector),\n        actors = [];\n\n    dom.forEach((element) => {\n        let actor = element[SAVE_PROP];\n\n        if (!actor) {\n            opts.element = element;\n            actor = element[SAVE_PROP] = new Actor(opts);\n        }\n\n        actors.push(actor);\n    });\n\n    return (actors.length > 1) ? new Iterator(actors) : actors[0];\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/inc/select-actor.js\n **/","/*\n    Calculators\n    ----------------------------------------\n    \n    Simple I/O snippets\n*/\n\"use strict\";\n\nvar utils = require('./utils.js'),\n\n    calc = {\n        \n        /*\n            Angle between points\n            \n            Translates the hypothetical line so that the 'from' coordinates\n            are at 0,0, then return the angle using .angleFromCenter()\n            \n            @param [object]: X and Y coordinates of from point\n            @param [object]: X and Y cordinates of to point\n            @return [radian]: Angle between the two points in radians\n        */\n        angle: function (pointA, pointB) {\n            var from = pointB ? pointA : {x: 0, y: 0},\n                to = pointB || pointA,\n                point = {\n                    x: to.x - from.x,\n                    y: to.y - from.y\n                };\n            \n            return this.angleFromCenter(point.x, point.y);\n        },\n\n        /*\n            Angle from center\n            \n            Returns the current angle, in radians, of a defined point\n            from a center (assumed 0,0)\n            \n            @param [number]: X coordinate of second point\n            @param [number]: Y coordinate of second point\n            @return [radian]: Angle between 0, 0 and point in radians\n        */\n        angleFromCenter: function (x, y) {\n            return this.radiansToDegrees(Math.atan2(y, x));\n        },\n        \n        /*\n            Convert degrees to radians\n            \n            @param [number]: Value in degrees\n            @return [number]: Value in radians\n        */\n        degreesToRadians: function (degrees) {\n            return degrees * Math.PI / 180;\n        },\n\n        /*\n            Dilate\n            \n            Change the progression between a and b according to dilation.\n            \n            So dilation = 0.5 would change\n            \n            a --------- b\n            \n            to\n            \n            a ---- b\n            \n            @param [number]: Previous value\n            @param [number]: Current value\n            @param [number]: Dilate progress by x\n            @return [number]: Previous value plus the dilated difference\n        */\n        dilate: function (a, b, dilation) {\n            return a + ((b - a) * dilation);\n        },\n            \n        /*\n            Distance\n            \n            Returns the distance between (0,0) and pointA, unless pointB\n            is provided, then we return the difference between the two.\n            \n            @param [object/number]: x and y or just x of point A\n            @param [object/number]: (optional): x and y or just x of point B\n            @return [number]: The distance between the two points\n        */\n        distance: function (pointA, pointB) {\n            return (typeof pointA === \"number\") ? this.distance1D(pointA, pointB) : this.distance2D(pointA, pointB);\n        },\n    \n        /*\n            Distance 1D\n            \n            Returns the distance between point A and point B\n            \n            @param [number]: Point A\n            @param [number]: (optional): Point B\n            @return [number]: The distance between the two points\n        */\n        distance1D: function (pointA, pointB) {\n            var bIsNum = (typeof pointB === 'number'),\n                from = bIsNum ? pointA : 0,\n                to = bIsNum ? pointB : pointA;\n    \n            return absolute(to - from);\n        },\n    \n      \n        /*\n            Distance 2D\n            \n            Returns the distance between (0,0) and point A, unless point B\n            is provided, then we return the difference between the two.\n            \n            @param [object]: x and y of point A\n            @param [object]: (optional): x and y of point B\n            @return [number]: The distance between the two points\n        */\n        distance2D: function (pointA, pointB) {\n            var bIsObj = (typeof pointB === \"object\"),\n                from = bIsObj ? pointA : {x: 0, y: 0},\n                to = bIsObj ? pointB : pointA,\n                point = {\n                    x: absolute(to.x - from.x),\n                    y: absolute(to.y - from.y)\n                };\n                \n            return this.hypotenuse(point.x, point.y);\n        },\n            \n        /*\n            Hypotenuse\n            \n            Returns the hypotenuse, side C, given the lengths of sides A and B.\n            \n            @param [number]: Length of A\n            @param [number]: Length of B\n            @return [number]: Length of C\n        */\n        hypotenuse: function (a, b) {\n            var a2 = a * a,\n                b2 = b * b,\n                c2 = a2 + b2;\n                \n            return Math.sqrt(c2);\n        },\n        \n        /*\n            Offset between two inputs\n            \n            Calculate the difference between two different inputs\n            \n            @param [Point]: First input\n            @param [Point]: Second input\n            @return [Offset]: Distance metrics between two points\n        */\n        offset: function (a, b) {\n            var offset = {};\n    \n            for (var key in b) {\n                if (b.hasOwnProperty(key)) {\n                    if (a.hasOwnProperty(key)) {\n                        offset[key] = b[key] - a[key];\n                    } else {\n                        offset[key] = 0;\n                    }\n                } \n            }\n\n            if (isNum(offset.x) && isNum(offset.y)) {\n                offset.angle = this.angle(a, b);\n                offset.distance = this.distance2D(a, b);\n            }\n                \n            return offset;\n        },\n        \n        /*\n            Point from angle and distance\n            \n            @param [object]: 2D point of origin\n            @param [number]: Angle from origin\n            @param [number]: Distance from origin\n            @return [object]: Calculated 2D point\n        */\n        pointFromAngleAndDistance: function (origin, angle, distance) {\n            var point = {};\n    \n    \t\tpoint.x = distance * Math.cos(angle) + origin.x;\n            point.y = distance * Math.sin(angle) + origin.y;\n    \n            return point;\n        },\n    \n        /*\n            Progress within given range\n            \n            Given a lower limit and an upper limit, we return the progress\n            (expressed as a number 0-1) represented by the given value, and\n            limit that progress to within 0-1.\n            \n            @param [number]: Value to find progress within given range\n            @param [number]: Lower limit if full range given, upper if not\n            @param [number] (optional): Upper limit of range\n            @return [number]: Progress of value within range as expressed 0-1\n        */\n        progress: function (value, limitA, limitB) {\n            var bIsNum = (typeof limitB === 'number'),\n                from = bIsNum ? limitA : 0,\n                to = bIsNum ? limitB : limitA,\n                range = to - from,\n                progress = (value - from) / range;\n    \n            return progress;\n        },\n        \n        /*\n            Convert radians to degrees\n            \n            @param [number]: Value in radians\n            @return [number]: Value in degrees\n        */\n        radiansToDegrees: function (radians) {\n            return radians * 180 / Math.PI;\n        },\n\n        /*\n            Return random number between range\n            \n            @param [number] (optional): Output minimum\n            @param [number] (optional): Output maximum\n            @return [number]: Random number within range, or 0 and 1 if none provided\n        */\n        random: function (min = 0, max = 1) {\n            return Math.random() * (max - min) + min;\n        },\n        \n        /*\n            Calculate relative value\n            \n            Takes the operator and value from a string, ie \"+=5\", and applies\n            to the current value to resolve a new target.\n            \n            @param [number]: Current value\n            @param [string]: Relative value\n            @return [number]: New value\n        */\n        relativeValue: function (current, rel) {\n            var newValue = current,\n                equation = rel.split('='),\n                operator = equation[0],\n                { unit, value } = utils.splitValUnit(equation[1]);\n\n            value = parseFloat(value);\n\n            switch (operator) {\n                case '+':\n                    newValue += value;\n                    break;\n                case '-':\n                    newValue -= value;\n                    break;\n                case '*':\n                    newValue *= value;\n                    break;\n                case '/':\n                    newValue /= value;\n                    break;\n            }\n            \n            if (unit) {\n                newValue += unit;\n            }\n    \n            return newValue;\n        },\n    \n    \n        /*\n            Restrict value to range\n            \n            Return value within the range of lowerLimit and upperLimit\n            \n            @param [number]: Value to keep within range\n            @param [number]: Lower limit of range\n            @param [number]: Upper limit of range\n            @return [number]: Value as limited within given range\n        */\n        restricted: function (value, min, max) {\n            var restricted = (min !== undefined) ? Math.max(value, min) : value;\n            restricted = (max !== undefined) ? Math.min(restricted, max) : restricted;\n    \n            return restricted;\n        },\n    \n        /*\n            Convert x per second to per frame velocity based on fps\n            \n            @param [number]: Unit per second\n            @param [number]: Frame duration in ms\n        */\n        speedPerFrame: function (xps, frameDuration) {\n            return (isNum(xps)) ? xps / (1000 / frameDuration) : 0;\n        },\n    \n        /*\n            Convert velocity into velicity per second\n            \n            @param [number]: Unit per frame\n            @param [number]: Frame duration in ms\n        */\n        speedPerSecond: function (velocity, frameDuration) {\n            return velocity * (1000 / frameDuration);\n        },\n    \n     \n        /*\n            Value in range from progress\n            \n            Given a lower limit and an upper limit, we return the value within\n            that range as expressed by progress (a number from 0-1)\n            \n            @param [number]: The progress between lower and upper limits expressed 0-1\n            @param [number]: Lower limit of range, or upper if limit2 not provided\n            @param [number] (optional): Upper limit of range\n            @return [number]: Value as calculated from progress within range (not limited within range)\n        */\n        value: function (progress, limitA, limitB) {\n            var bIsNum = (typeof limitB === 'number'),\n                from = bIsNum ? limitA : 0,\n                to = bIsNum ? limitB : limitA;\n    \n            return (- progress * from) + (progress * to) + from; \n        },\n    \n    \n        /*\n            Eased value in range from progress\n            \n            Given a lower limit and an upper limit, we return the value within\n            that range as expressed by progress (a number from 0-1)\n            \n            @param [number]: The progress between lower and upper limits expressed 0-1\n            @param [number]: Lower limit of range, or upper if limit2 not provided\n            @param [number]: Upper limit of range\n            @param [function]: Easing to apply to value\n            @return [number]: Value as calculated from progress within range (not limited within range)\n        */\n        valueEased: function (progress, from, to, easing) {\n            var easedProgress = easing(progress);\n            \n            return this.value(easedProgress, from, to);\n        }\n    },\n\n    /*\n        Caching functions used multiple times to reduce filesize and increase performance\n    */\n    isNum = utils.isNum,\n    absolute = Math.abs;\n    \nmodule.exports = calc;\n\n\n/** WEBPACK FOOTER **\n ** ./src/inc/calc.js\n **/","\"use strict\";\n\nmodule.exports = function (values, terms, delimiter, chop) {\n    var combined = '',\n        key = '',\n        i = 0,\n        numTerms = terms.length;\n\n    for (; i < numTerms; i++) {\n        key = terms[i];\n\n        if (values.hasOwnProperty(key)) {\n            combined += values[key] + delimiter;\n        }\n    }\n\n    if (chop) {\n        combined = combined.slice(0, -chop);\n    }\n\n    return combined;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/manipulators/create-delimited.js\n **/","var splitCommaDelimited = require('./split-comma-delimited'),\n    functionBreak = require('./function-break');\n\nmodule.exports = function (value, terms) {\n    var splitValue = {},\n        numTerms = terms.length,\n        colors = splitCommaDelimited(functionBreak(value)),\n        i = 0;\n\n    for (; i < numTerms; i++) {\n        splitValue[terms[i]] = (colors[i] !== undefined) ? colors[i] : 1;\n    }\n\n    return splitValue;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/manipulators/get-color-values.js\n **/","module.exports = function (value, prefix) {\n    return prefix + '(' + value + ')';\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/manipulators/function-create.js\n **/","\"use strict\";\n\nmodule.exports = {\n    color: {\n        min: 0,\n        max: 255,\n        round: true\n    },\n    opacity: {\n        min: 0,\n        max: 1\n    },\n    percent: {\n        min: 0,\n        max: 100,\n        unit: '%'\n    }\n};\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/settings/default-props.js\n **/","\"use strict\";\n\nvar X = 'X',\n    Y = 'Y',\n    ALPHA = 'Alpha',\n\n    terms = {\n        colors: ['Red', 'Green', 'Blue', ALPHA],\n        positions: [X, Y, 'Z'],\n        dimensions: ['Top', 'Right', 'Bottom', 'Left'],\n        shadow: [X, Y, 'Radius', 'Spread', 'Color'],\n        hsl: ['Hue', 'Saturation', 'Lightness', ALPHA]\n    };\n\nmodule.exports = terms;\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/settings/dictionary.js\n **/","/*\n    Utility functions\n*/\n\"use strict\";\n\nvar protectedProperties = ['scope',  'dom'],\n    \n    isProtected = function (key) {\n        return (protectedProperties.indexOf(key) !== -1);\n    },\n\n    /*\n        Get var type as string\n        \n        @param: Variable to test\n        @return [string]: Returns, for instance 'Object' if [object Object]\n    */\n    varType = function (variable) {\n        return Object.prototype.toString.call(variable).slice(8, -1);\n    };\n\nmodule.exports = {\n\n    /*\n        Iterate over an object and fire a callback for every item in it\n\n        @param [object]: Properties\n        @param [function]: Callback to fire\n    */\n    each: function (props, callback) {\n        var keys = Object.keys(props),\n            numKeys = keys.length;\n\n        for (let i = 0; i < numKeys; i++) {\n            let key = keys[i],\n                prop = props[key];\n\n            if (callback(key, prop) === false) {\n                break;\n            }\n        }\n    },\n    \n    /*\n        Has one object changed from the other\n        \n        Compares the two provided inputs and returns true if they are different\n        \n        @param [object]: Input A\n        @param [object]: Input B\n        @return [boolean]: True if different\n    */\n    hasChanged: function (a, b) {\n        var hasChanged = false,\n            key = '';\n\n        for (key in b) {\n            if (a.hasOwnProperty(key) && b.hasOwnProperty(key)) {\n                if (a[key] !== b[key]) {\n                    hasChanged = true;\n                }\n            } else {\n                hasChanged = true;\n            }\n        }\n    \n        return hasChanged;\n    },\n    \n    /*\n        Is this var a number?\n        \n        @param: Variable to test\n        @return [boolean]: Returns true if typeof === 'number'\n    */\n    isNum: function (num) {\n        return (typeof num === 'number');\n    },\n    \n    /*\n        Is this var an object?\n        \n        @param: Variable to test\n        @return [boolean]: Returns true if typeof === 'object'\n    */\n    isObj: function (obj) {\n        return (typeof obj === 'object');\n    },\n    \n    /*\n        Is this var a function ? \n        \n        @param: Variable to test\n        @return [boolean]: Returns true if this.varType === 'Function'\n    */\n    isFunc: function (obj) {\n        return (varType(obj) === 'Function'); \n    },\n    \n    /*\n        Is this var a string ? \n        \n        @param: Variable to test\n        @return [boolean]: Returns true if typeof str === 'string'\n    */\n    isString: function (str) {\n        return (typeof str === 'string'); \n    },\n\n\n    /*\n        Is this a relative value assignment?\n        \n        @param [string]: Variable to test\n        @return [boolean]: If this looks like a relative value assignment\n    */\n    isRelativeValue: function (value) {\n        return (value && value.indexOf && value.indexOf('=') > 0);\n    },\n    \n    /*\n        Is this var an array ? \n        \n        @param: Variable to test\n        @return [boolean]: Returns true if this.varType === 'Array'\n    */\n    isArray: function (arr) {\n        return (varType(arr) === 'Array');\n    },\n    \n    /*\n        Copy object or array\n        \n        Checks whether base is an array or object and makes\n        appropriate copy\n        \n        @param [array || object]: Array or object to copy\n        @param [array || object]: New copy of array or object\n    */\n    copy: function (base) {\n        return (this.isArray(base)) ? this.copyArray(base) : this.copyObject(base);\n    },\n    \n    /*\n        Deep copy an object\n        \n        Iterates over an object and creates a new copy of every item,\n        deep copying if it finds any objects/arrays\n        \n        @param [object]: Object to copy\n        @param [object]: New copy of object\n    */\n    copyObject: function (base) {\n        var newObject = {};\n        \n        for (var key in base) {\n            if (base.hasOwnProperty(key)) {\n                newObject[key] = (this.isObj(base[key]) && !isProtected(key)) ? this.copy(base[key]) : base[key];\n            }\n        }\n        \n        return newObject;\n    },\n    \n    /*\n        Deep copy an array\n        \n        Loops through an array and creates a new copy of every item,\n        deep copying if it finds any objects/arrays\n        \n        @param [array]: Array to copy\n        @return [array]: New copy of array\n    */\n    copyArray: function (base) {\n        var newArray = [],\n            length = base.length,\n            i = 0;\n        \n        for (; i < length; i++) {\n            newArray[i] = base[i];\n        }\n        \n        return newArray;\n    },\n    \n    /*\n        Non-destructive merge of object or array\n        \n        @param [array || object]: Array or object to use as base\n        @param [array || object]: Array or object to overwrite base with\n        @return [array || object]: New array or object\n    */\n    merge: function (base, overwrite) {\n        return (this.isArray(base)) ? this.copyArray(overwrite) : this.mergeObject(base, overwrite);\n    },\n    \n    /*\n        Non-destructive merge of object\n        \n        @param [object]: Object to use as base\n        @param [object]: Object to overwrite base with\n        @return [object]: New object\n    */\n    mergeObject: function (base, overwrite) {\n        var hasBase = this.isObj(base),\n            newObject = hasBase ? this.copy(base) : this.copy(overwrite),\n            key = '';\n\n        if (hasBase) {\n            for (key in overwrite) {\n                if (overwrite.hasOwnProperty(key)) {\n                    newObject[key] = (this.isObj(overwrite[key]) && !isProtected(key)) ? this.merge(base[key], overwrite[key]) : overwrite[key];\n                }\n            }\n        }\n        return newObject;\n    },\n    \n    /*\n        Split a value into a value/unit object\n        \n            \"200px\" -> { value: 200, unit: \"px\" }\n            \n        @param [string]: Value to split\n        @return [object]: Object with value and unit props\n    */\n    splitValUnit: function (value) {\n        let splitVal = value.match(/(-?\\d*\\.?\\d*)(.*)/);\n\n        return {\n            value: splitVal[1],\n            unit:  splitVal[2]\n        };\n    },\n\n    /*\n        Create stepped version of 0-1 progress\n        \n        @param [number]: Current value\n        @param [int]: Number of steps\n        @return [number]: Stepped value\n    */\n    stepProgress: function (progress, steps) {\n        var segment = 1 / (steps - 1),\n            target = 1 - (1 / steps),\n            progressOfTarget = Math.min(progress / target, 1);\n\n        return Math.floor(progressOfTarget / segment) * segment;\n    },\n    \n    /*\n        Generate current timestamp\n        \n        @return [timestamp]: Current UNIX timestamp\n    */\n    currentTime: function () {\n\t    return (typeof performance !== \"undefined\") ? performance.now() : new Date().getTime();\n    }\n    \n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/inc/utils.js\n **/","module.exports = function (value) {\n    return (typeof value === 'string') ? value.split(' ') : [value];\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/manipulators/split-space-delimited.js\n **/","\"use strict\";\n\nvar each = require('../../inc/utils').each,\n    transformDictionary = require('./transform-dictionary'),\n    transformProps = transformDictionary.props,\n\n    TRANSLATE_Z = 'translateZ';\n\nmodule.exports = function (output, cache) {\n    var css = {},\n        transform = '',\n        transformHasZ = false;\n        \n    // Loop through output, check for transform properties\n    each(output, function (key, rule) {\n        // If this is a transform property, add to transform string\n        if (transformProps[key]) {\n            transform += key + '(' + rule + ')';\n            transformHasZ = (key === TRANSLATE_Z) ? true : transformHasZ;\n        \n        // Or just assign directly\n        } else {\n            if (rule !== cache[key]) {\n                cache[key] = css[key] = rule;\n            }\n        }\n    });\n\n    // If we have transform properties, add translateZ\n    if (transform !== '') {\n        if (!transformHasZ) {\n            transform += ' ' + TRANSLATE_Z + '(0px)';\n        }\n\n        if (transform !== cache.transform) {\n            css.transform = transform;\n        }\n        \n        cache.transform = transform;\n    }\n\n    return css;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/roles/css/build.js\n **/","var TRANSLATE = 'translate';\n\nmodule.exports = {\n    x: TRANSLATE + 'X',\n    y: TRANSLATE + 'Y',\n    z: TRANSLATE + 'Z'\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/roles/css/map.js\n **/","var COLOR = 'color',\n    POSITIONS = 'positions',\n    DIMENSIONS = 'dimensions',\n    SHADOW = 'shadow',\n    ANGLE = 'angle',\n    ALPHA = 'alpha',\n    PX = 'px';\n\nmodule.exports = {\n    // Color properties\n    color: COLOR,\n    backgroundColor: COLOR,\n    outlineColor: COLOR,\n    fill: COLOR,\n    stroke: COLOR,\n    // Border\n    borderColor: COLOR,\n    borderTopColor: COLOR,\n    borderRightColor: COLOR,\n    borderBottomColor: COLOR,\n    borderLeftColor: COLOR,\n    borderRadius: PX,\n    // Dimensions\n    margin: DIMENSIONS,\n    padding: DIMENSIONS,\n    width: PX,\n    height: PX,    \n    // Positions\n    backgroundPosition: POSITIONS,\n    perspectiveOrigin: POSITIONS,\n    transformOrigin: POSITIONS,    \n    // Shadows\n    textShadow: SHADOW,\n    boxShadow: SHADOW,    \n    // Transform properties\n    rotate: ANGLE,\n    rotateX: ANGLE,\n    rotateY: ANGLE,\n    rotateZ: ANGLE,\n    skewX: ANGLE,\n    skewY: ANGLE,\n    translateX: PX,\n    translateY: PX,\n    translateZ: PX,\n    perspective: PX,\n    opacity: ALPHA\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/roles/css/type-map.js\n **/","var each = require('../../inc/utils').each,\n    transformDictionary = require('../css/transform-dictionary'),\n    transformProps = transformDictionary.props,\n    zeroNotZero = 0.0001;\n\nmodule.exports = function (output, origin) {\n    var props = {},\n        hasTransform = false,\n        scale = output.scale !== undefined ? output.scale || zeroNotZero : output.scaleX || 1,\n        scaleY = output.scaleY !== undefined ? output.scaleY || zeroNotZero : scale || 1,\n        transformOriginX = origin.x,\n        transformOriginY = origin.y,\n        scaleTransformX = - transformOriginX * (scale * 1),\n        scaleTransformY = - transformOriginY * (scaleY * 1),\n        scaleReplaceX = transformOriginX / scale,\n        scaleReplaceY = transformOriginY / scaleY,\n        transform = {\n            translate: `translate(${output.translateX}, ${output.translateY}) `,\n            scale: `translate(${scaleTransformX}, ${scaleTransformY}) scale(${scale}, ${scaleY}) translate(${scaleReplaceX}, ${scaleReplaceY}) `,\n            rotate: `rotate(${output.rotate}, ${transformOriginX}, ${transformOriginY}) `,\n            skewX: `skewX(${output.skewX}) `,\n            skewY: `skewY(${output.skewY}) `\n        };\n\n    each(output, function (key, value) {\n        if (transformProps[key]) {\n            hasTransform = true;\n        } else {\n            props[key] = value;\n        }\n    });\n\n    if (hasTransform) {\n        props.transform = '';\n\n        each(transform, function (key, value) {\n            var defaultValue = (key === 'scale') ? '1' : '0';\n            props.transform += value.replace(/undefined/g, defaultValue);\n        });\n    }\n\n    return props;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/roles/svg/build.js\n **/","var COLOR = 'color',\n    SCALE = 'scale';\n\nmodule.exports = {\n    fill: COLOR,\n    stroke: COLOR,\n    scale: SCALE,\n    scaleX: SCALE,\n    scaleY: SCALE,\n    transformOrigin: 'positions',\n    d: 'complex'\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/roles/svg/type-map.js\n **/","var STROKE = 'stroke';\n\nmodule.exports = {\n    opacity: STROKE + '-opacity',\n    width: STROKE + '-width',\n    miterlimit: STROKE + '-miterlimit'\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/roles/path/map.js\n **/","\"use strict\";\n\nvar Queue = function () {\n        this.clear();\n    };\n\nQueue.prototype = {\n    \n    /*\n        Add a set of arguments to queue\n    */\n    add: function () {\n        this.queue.push([].slice.call(arguments));\n    },\n    \n    /*\n        Get next set of arguments from queue\n    */\n    next: function (direction) {\n        var queue = this.queue,\n            returnVal = false,\n            index = this.index;\n            \n        direction = (arguments.length) ? direction : 1;\n        \n        // If our index is between 0 and the queue length, return that item\n        if (index >= 0 && index < queue.length) {\n            returnVal = queue[index];\n            this.index = index + direction;\n        \n        // Or clear\n        } else {\n            this.clear();\n        }\n        \n        return returnVal;\n    },\n\n    /*\n        Replace queue with empty array\n    */\n    clear: function () {\n        this.queue = [];\n        this.index = 0;\n    }\n};\n\nmodule.exports = Queue;\n\n\n/** WEBPACK FOOTER **\n ** ./src/inc/Queue.js\n **/","/*\n    @param [string || NodeList || jQuery object]:\n        If string, treated as selector.\n        If not, treated as preexisting NodeList || jQuery object.\n*/\nmodule.exports = function (selector) {\n    var nodes = (typeof selector === 'string') ? document.querySelectorAll(selector) : selector,\n        elements = [];\n\n    // If jQuery selection, get array of Elements\n    if (nodes.get) {\n        elements = nodes.get();\n\n    // Or convert NodeList to array\n    } else if (nodes.length) {\n        elements = [].slice.call(nodes);\n\n    // Or if it's just an Element, put into array\n    } else {\n        elements.push(nodes);\n    }\n\n    return elements;\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/inc/select-dom.js\n **/","\"use strict\";\n\nvar valueTypeManager = require('../value-types/manager'),\n    calc = require('../inc/calc'),\n    utils = require('../inc/utils'),\n    each = utils.each,\n    Action = require('../actions/Action'),\n    defaultAction = new Action(),\n    Watch = require('../actions/Watch'),\n    watcher = new Watch(),\n\n    createMapper = function (role, mappedValues) {\n        return function (name, val) {\n            mappedValues[role.map(name)] = val;\n        };\n    },\n\n    /*\n        Check all Actions for `onEnd`, return true if all are true\n\n        @param [Actor]\n        @param [boolean]\n        @returns [boolean]\n    */\n    checkAllActionsHaveEnded = function (actor, hasChanged) {\n        var hasEnded = true,\n            values = actor.state.values;\n\n        each(actor.activeActions, (key, action) => {\n            // Return if action has been deleted elsewhere\n            if (!action) { return; }\n\n            if (action.onFrame) {\n                action.onFrame.call(actor, values, actor, action);\n            }\n\n            if (action.onUpdate && hasChanged) {\n                action.onUpdate.call(actor, values, actor, action);\n            }\n\n            if (action.hasEnded && action.hasEnded(actor, hasChanged) === false) {\n                hasEnded = false;\n            } else {\n                if (action.onComplete) {\n                    action.onComplete.call(actor, actor, action);\n                }\n                actor.unbindAction(key);\n            }\n        });\n\n        return hasEnded;\n    },\n\n    /*\n        Update the Actor and its values\n\n        @param [int]: Timestamp of rAF call\n        @param [int]: Time since last frame\n    */\n    update = function (framestamp, frameDuration) {\n        var numActiveValues = this.activeValues.length,\n            numActiveParents = this.activeParents.length,\n            numRoles = this.roles.length,\n            state = this.state,\n            hasChanged = false;\n\n        // Update values\n        for (let i = 0; i < numActiveValues; i++) {\n            // Get value and key\n            let key = this.activeValues[i];\n            let value = this.values[key];\n            let action = (!value.action || value.action && !value.action.isActive) ? defaultAction : value.action;\n\n            // Fire action onFrameStart if not already fired\n            if (action.onFrameStart && action.lastUpdate !== framestamp) {\n                action.onFrameStart(this, frameDuration, framestamp);\n                action.lastUpdate = framestamp;\n            }\n\n            // Calculate new value\n            let updatedValue = utils.isString(value.watch) ? watcher.process(this, value) : action.process(this, value, key, frameDuration);\n\n            // Limit if this action does that kind of thing\n            if (action.limit && value.hasRange) {\n                updatedValue = action.limit(updatedValue, value);\n            }\n\n            // Round value if round is true\n            if (value.round) {\n                updatedValue = Math.round(updatedValue);\n            }\n\n            // Update frameChange\n            value.frameChange = updatedValue - value.current;\n\n            // Calculate velocity if Action hasn't\n            if (!action.calculatesVelocity) {\n                value.velocity = calc.speedPerSecond(value.frameChange, frameDuration);\n            }\n\n            // Update current speed\n            value.speed = Math.abs(value.velocity);\n\n            // Check if value's changed\n            if (value.current !== updatedValue || this.firstFrame) {\n                hasChanged = true;\n            }\n\n            // Set new current \n            value.current = updatedValue;\n            let valueState = (value.unit) ? updatedValue + value.unit : updatedValue;\n\n            // Put value in state if no parent\n            if (!value.parent) {\n                state.values[key] = valueState;\n\n            // Or, add to parent state to be combined later\n            } else {\n                state[value.parent] = state[value.parent] || {};\n                state[value.parent][value.propName] = valueState;\n            }\n        }\n\n        // Update parent values from calculated children\n        for (let i = 0; i < numActiveParents; i++) {\n            let key = this.activeParents[i];\n            let value = this.values[key];\n\n            // Update parent value current property\n            value.current = valueTypeManager[value.type].combine(state[key], value.template);\n\n            // Update state\n            state.values[key] = value.current;\n        }\n\n        // Fire `frame` and `update` callbacks on all Roles\n        for (let i = 0; i < numRoles; i++) {\n            let role = this.roles[i];\n            let mappedValues = {};\n\n            each(state.values, createMapper(role, mappedValues));\n\n            if (role.frame) {\n                role.frame.call(this, mappedValues, this);\n            }\n\n            if (role.update && hasChanged) {\n                role.update.call(this, mappedValues, this);\n            }\n        }\n\n        // Reset hasChanged before further Actions might affect this\n        this.hasChanged = false;\n\n        if (this.isActive) {\n            this.isActive = false;\n\n            if (checkAllActionsHaveEnded(this, hasChanged)) {\n                // Fire `complete` callbacks\n                for (let i = 0; i < numRoles; i++) {\n                    let role = this.roles[i];\n                    if (role.complete) {\n                        role.complete.call(this, this);\n                    }\n                }\n\n                if (!this.isActive) {\n                    this.next();\n                }\n            } else {\n                this.isActive = true;\n                this.firstFrame = false;\n            }\n        }\n                \n        this.framestamp = framestamp;\n    };\n\nmodule.exports = update;\n\n\n/** WEBPACK FOOTER **\n ** ./src/actor/update.js\n **/","var valueTypesManager = require('../value-types/manager'),\n    calc = require('../inc/calc'),\n    utils = require('../inc/utils'),\n    isNum = utils.isNum,\n    each = utils.each;\n\nconst numericalValues = ['current', 'to', 'min', 'max', 'velocity', 'friction', 'spring'],\n    numNumericalValues = numericalValues.length,\n    defaultValue = {\n        current: 0,\n        velocity: 0,\n        speed: 0,\n        frameChange: 0\n    };\n\nfunction checkNumericalValue(name) {\n    return (numericalValues.indexOf(name) > -1);\n}\n\n/*\n    Check Role typeMaps to see if this value name has been mapped\n    to a specific value type\n\n    @param [string]\n    @param [array]\n    @returns [string]: Value type\n*/\nfunction checkRoles(name, roles) {\n    var valueType;\n\n    each(roles, (key, role) => {\n        if (role._typeMap) {\n            valueType = role._typeMap[role.map(name)] || valueType;\n        }\n    });\n\n    return valueType;\n}\n\n/*\n    Check value for special type\n\n    @param [object]\n    @param [object]\n    @param [object]\n    @param [string]\n    @returns [string || false]\n*/\nfunction checkValueType(existingValue, newValue, scope, valueName) {\n    var valueType;\n\n    // Check existing value for type already set\n    if (existingValue && existingValue.type) {\n        valueType = existingValue.type;\n    \n    } else {\n        // Or check Role _typeMap properties\n        if (scope.roles) {\n            valueType = checkRoles(valueName, scope.roles);\n        }\n\n        // Finally run tests\n        if (!valueType && utils.isString(newValue.current)) {\n            valueType = valueTypesManager.test(newValue.current);\n        }\n    }\n\n    return valueType;\n}\n\n/*\n    Resolve a property\n\n    @param [string]\n    @param [string || function || number]\n    @param [object]\n    @param [object]\n    @returns [number]\n*/\nfunction resolve(name, prop, value, scope) {\n    let isNumericalValue = checkNumericalValue(name);\n\n    // If function, resolve\n    if (utils.isFunc(prop) && isNumericalValue) {\n        prop = prop.call(scope, scope);\n    }\n\n    // If string, check for relative numbers and units\n    if (utils.isString(prop)) {\n        // If relative value\n        if (prop.indexOf('=') > 0) {\n            prop = calc.relativeValue(value.current, prop);\n        }\n\n        // If unit\n        if (isNumericalValue) {\n            splitUnit(prop, value);\n        }\n    }\n\n    if (isNumericalValue) {\n        prop = parseFloat(prop);\n    }\n\n    return prop;\n}\n\n/*\n    Split a value into sub-values\n\n    @param [string]\n    @param [object]\n    @param [object]\n    @param [valueTypeHandler]\n    @returns [object]\n*/\nfunction split(name, value, scope, valueTypeHandler) {\n    var splitValues = {},\n        i = 0;\n\n    for (; i < numNumericalValues; i++) {\n        let propName = numericalValues[i];\n        let splitProp = {};\n\n        if (value.hasOwnProperty(propName)) {\n            let valueProp = value[propName];\n\n            // If we need to first resolve this, resolve\n            if (utils.isFunc(valueProp)) {\n                valueProp = valueProp.call(scope, scope);\n            }\n\n            if (!utils.isString(valueProp)) {\n                continue;\n            }\n\n            splitProp = valueTypeHandler.split(valueProp);\n\n            // Assign split properties to each child value\n            each(splitProp, (key, prop) => {\n                // Create new value if none exists\n                splitValues[key] = splitValues[key] || utils.copy(valueTypesManager.defaultProps(value.type, key));\n                splitValues[key][propName] = prop;\n\n                if (utils.isString(splitProp[key])) {\n                    splitUnit(splitValues[key][propName], splitValues[key]);\n                }\n            });\n        }\n    }\n\n    return splitValues;\n}\n\n/*\n    Split value into number and unit, and set unit to value\n\n    @param [string]\n    @param [object]\n*/\nfunction splitUnit(property, hostValue) {\n    if (utils.isNum(property)) { return property; }\n    let returnVal = property,\n        { value, unit } = utils.splitValUnit(property);\n\n    if (!isNaN(value)) {\n        returnVal = value;\n        if (unit) {\n            hostValue.unit = unit;\n        }\n    }\n\n    return returnVal;\n}\n\n/*\n    Preprocess incoming values, splitting non-numerical values\n    into sub-values ie hex\n\n    @param [object]\n    @param [object]\n    @param [object]\n    @param [string]\n*/\nfunction preprocess(existing, incoming, scope, defaultProp) {\n    var values = {};\n\n    each(incoming, (key, value) => {\n        let existingValue = existing[key],\n            newValue = {};\n\n        if (utils.isObj(value)) {\n            newValue = value;\n        } else {\n            newValue[defaultProp] = value;\n        }\n\n        // If value doesn't have a special type, check for one\n        newValue.type = checkValueType(existingValue, newValue, scope, key);\n        newValue.watch = utils.isString(newValue.watch) ? newValue.watch : undefined;\n\n        values[key] = newValue;\n\n        // If we have a type property, split/assign default props\n        if (newValue.type) {\n            let typeHandler = valueTypesManager[newValue.type];\n\n            // If valueType handler has a split function, split this value\n            if (typeHandler.split) {\n                let splitValues = split(key, newValue, scope, typeHandler);\n                newValue.children = {};\n\n                each(splitValues, (childName, childValue) => {\n                    childValue = utils.merge(newValue, childValue);\n                    childValue.parent = childValue.name = key;\n                    childValue.propName = childName;\n\n                    delete childValue.type;\n                    delete childValue.children;\n\n                    newValue.children[childName] = values[key + childName] = childValue;\n                });\n\n                if (typeHandler.template) {\n                    newValue.template = existingValue ? existingValue.template : typeHandler.template(newValue.current);\n                }\n\n            // Or just assign default properties for this value\n            } else {\n                values[key] = utils.merge(valueTypesManager.defaultProps(newValue.type, key), newValue);\n            }\n        }\n    });\n\n    return values;\n}\n\nmodule.exports = {\n\n    /*\n        Flip value target/origin\n    */\n    flip: function (value) {\n        var target = (value.target !== undefined) ? value.target : value.current;\n        value.target = value.to = value.origin;\n        value.origin = target;\n    },\n\n    /*\n        Merge existing and incoming values, resolving properties\n        set as functions and splitting non-numerical values ie hex\n\n        @param [object]\n        @param [object]\n        @param [object]\n        @param [string] (optional)\n        @param [object]\n        @returns [object]: New values object\n    */\n    process: function (existing, incoming, inherit, defaultProp, scope) {\n        existing = existing || {};\n        defaultProp = defaultProp || 'current';\n        let preprocessed = preprocess(existing, incoming, scope, defaultProp);\n\n        each(preprocessed, (key, value) => {\n            let newValue = existing[key] || utils.copy(defaultValue),\n                hasChildren = (value.children !== undefined),\n                defaultActionValue = inherit.action ? inherit.action.getDefaultValue() : {};\n\n            value.action = inherit.action;\n\n            each(defaultActionValue, (propName, defaultActionProp) => {\n                newValue[propName] = (inherit.hasOwnProperty(propName) && !value.hasOwnProperty(propName)) ? inherit[propName] : defaultActionProp;\n            });\n\n            each(value, (valueName, valueProp) => {\n                // If property is not undefined or a number, resolve\n                if (valueProp !== undefined && !isNum(valueProp) && !hasChildren) {\n                    valueProp = resolve(valueName, valueProp, newValue, scope);\n                }\n\n                newValue[valueName] = valueProp;\n\n                // Set internal target if this property is 'to'\n                if (valueName === 'to') {\n                    newValue.target = newValue.to;\n                }\n            });\n\n            newValue.origin = newValue.current;\n            newValue.hasRange = (isNum(newValue.min) || isNum(newValue.max)) ? true : false;\n\n            existing[key] = newValue;\n            scope.updateOrder(key, utils.isString(newValue.watch), hasChildren);\n        });\n\n        return existing;\n    }\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/actor/value-operations.js\n **/","var Role = require('./Role');\n\nmodule.exports = new Role({\n    init: function (actor) {\n        if (actor.init) {\n            actor.init(actor);\n        }\n    },\n\n    start: function (actor) {\n        if (actor.onStart) {\n            actor.onStart(actor);\n        }\n    },\n\n    frame: function (state, actor) {\n        if (actor.onFrame) {\n            actor.onFrame(state, actor);\n        }\n    },\n\n    update: function (state, actor) {\n        if (actor.onUpdate) {\n            actor.onUpdate(state, actor);\n        }\n    },\n\n    complete: function (actor) {\n        if (actor.onComplete) {\n            actor.onComplete(actor);\n        }\n    }\n});\n\n\n/** WEBPACK FOOTER **\n ** ./src/roles/defaultRole.js\n **/","\"use strict\";\n\nvar // [number]: Default max size of history\n    maxHistorySize = 3,\n    \n    /*\n        History constructor\n        \n        @param [var]: Variable to store in first history slot\n        @param [int] (optional): Maximum size of history\n    */\n    History = function (obj, max) {\n        this.max = max || maxHistorySize;\n        this.entries = [];\n        this.add(obj);\n    };\n    \nHistory.prototype = {\n    \n    /*\n        Push new var to history\n        \n        Shift out oldest entry if we've reached maximum capacity\n        \n        @param [var]: Variable to push into history.entries\n    */\n    add: function (obj) {\n        var currentSize = this.getSize();\n        \n        this.entries.push(obj);\n        \n        if (currentSize >= this.max) {\n            this.entries.shift();\n        }\n    },\n    \n    /*\n        Get variable at specified index\n\n        @param [int]: Index\n        @return [var]: Var found at specified index\n    */\n    get: function (i) {\n        i = (typeof i === 'number') ? i : this.getSize() - 1;\n\n        return this.entries[i];\n    },\n    \n    /*\n        Get the second newest history entry\n        \n        @return [var]: Entry found at index size - 2\n    */\n    getPrevious: function () {\n        return this.get(this.getSize() - 2);\n    },\n    \n    /*\n        Get current history size\n        \n        @return [int]: Current length of entries.length\n    */\n    getSize: function () {\n        return this.entries.length;\n    }\n    \n};\n\nmodule.exports = History;\n\n\n/** WEBPACK FOOTER **\n ** ./src/inc/History.js\n **/","class Controls {\n    constructor(actor, action, hasStarted) {\n        this.actor = actor;\n        this.action = action;\n\n        if (hasStarted) {\n            this.id = this.bindAction();\n            this.action.activate();\n        }\n    }\n\n    start(input) {\n        this.id = this.bindAction();\n        this.actor.start(this.id, input);\n        this.action.activate();\n        return this;\n    }\n\n    stop() {\n        this.actor.unbindAction(this.id);\n        this.action.deactivate();\n\n        return this;\n    }\n\n    pause() {\n        this.action.deactivate();\n        return this;\n    }\n\n    resume() {\n        this.action.activate();\n        return this;\n    }\n\n    toggle() {\n        let resume = this.actor.hasAction(this.id) ? this.resume : this.start;\n        return this.action.isActive ? this.pause() : resume.call(this);\n    }\n\n    then(...args) {\n        this.actor.then(...args);\n        return this;\n    }\n\n    bindAction() {\n        return this.actor.bindAction(this.action, this.id);\n    }\n}\n\nmodule.exports = Controls;\n\n\n/** WEBPACK FOOTER **\n ** ./src/controls/Controls.js\n **/","/*\n    Easing functions\n    ----------------------------------------\n    \n    Generates and provides easing functions based on baseFunction definitions\n    \n    A call to easingFunction.get('functionName') returns a function that can be passed:\n        @param [number]: Progress 0-1\n        @param [number] (optional): Amp modifier, only accepted in some easing functions\n                                    and is used to adjust overall strength\n        @return [number]: Eased progress\n        \n    We can generate new functions by sending an easing function through easingFunction.extend(name, method).\n    Which will make nameIn, nameOut and nameInOut functions available to use.\n        \n    Easing functions from Robert Penner\n    http://www.robertpenner.com/easing/\n        \n    Bezier curve interpretor created from Gaëtan Renaudeau's original BezierEasing  \n    https://github.com/gre/bezier-easing/blob/master/index.js  \n    https://github.com/gre/bezier-easing/blob/master/LICENSE\n*/\n\"use strict\";\n\nvar Easing = require('./Easing'),\n    easingFunction,\n    \n    // Generate easing function with provided power\n    generatePowerEasing = function (power) {\n        return function (progress) {\n            return Math.pow(progress, power);\n        };\n    },\n\n    /*\n        Each of these base functions is an easeIn\n        \n        On init, we use EasingFunction.mirror and .reverse to generate easeInOut and\n        easeOut functions respectively.\n    */\n    baseEasing = {\n        circ: function (progress) {\n            return 1 - Math.sin(Math.acos(progress));\n        },\n        back: function (progress) {\n            var strength = 1.5;\n\n            return (progress * progress) * ((strength + 1) * progress - strength);\n        }\n    };\n\n// Generate power easing easing\n['ease', 'cubic', 'quart', 'quint'].forEach(function (easingName, i) {\n    baseEasing[easingName] = generatePowerEasing(i + 2);\n});\n\n// Generate in/out/inOut variations\nfor (var key in baseEasing) {\n    if (baseEasing.hasOwnProperty(key)) {\n        easingFunction = new Easing(baseEasing[key]);\n        baseEasing[key + 'In'] = easingFunction.in;\n        baseEasing[key + 'Out'] = easingFunction.out;\n        baseEasing[key + 'InOut'] = easingFunction.inOut;\n    }\n}\n\n/*\n    Linear easing adjustment\n    \n    The default easing method, not added with .extend as it has no Out or InOut\n    variation.\n    \n    @param [number]: Progress, from 0-1\n    @return [number]: Unadjusted progress\n*/\nbaseEasing.linear = function (progress) {\n    return progress;\n};\n\nmodule.exports = baseEasing;\n\n\n/** WEBPACK FOOTER **\n ** ./src/actions/tween/preset-easing.js\n **/","var Controls = require('../../controls/Controls');\n\nclass TweenControls extends Controls {\n    restart() {\n        this.action.restart();\n        return this;\n    }\n\n    reverse() {\n        this.action.reverse();\n        return this;\n    }\n\n    seek(progress) {\n        if (!this.actor.hasAction(this.id)) {\n            this.start().pause();\n        }\n\n        this.action.elapsed = this.action.duration * progress;\n\n        if (!this.action.isActive) {\n            this.action.activate();\n            this.actor.process.fire();\n            this.action.deactivate();\n        }\n\n        return this;\n    }\n}\n\nmodule.exports = TweenControls;\n\n\n/** WEBPACK FOOTER **\n ** ./src/actions/tween/TweenControls.js\n **/","\"use strict\";\n\nvar calc = require('../../inc/calc'),\n    utils = require('../../inc/utils'),\n    speedPerFrame = calc.speedPerFrame;\n\n/*\n    Add core physics simulations\n*/\nvar simulations = {\n    /*\n        Velocity\n        \n        The default .run() simulation.\n        \n        Applies any set deceleration and acceleration to existing velocity\n    */\n    velocity: function (value, duration) {\n        value.velocity = value.velocity - speedPerFrame(value.deceleration, duration) + speedPerFrame(value.acceleration, duration);\n\n        return simulations.friction(value, duration);\n    },\n\n    /*\n        Glide\n        \n        Emulates touch device scrolling effects with exponential decay\n        http://ariya.ofilabs.com/2013/11/javascript-kinetic-scrolling-part-2.html\n    */\n    glide: function (value, duration, started) {\n        var timeUntilFinished = - utils.currentTime() - started,\n            delta = - value.to * Math.exp(timeUntilFinished / value.timeConstant);\n\n        return (value.to + delta) - value.current;\n    },\n\n    /*\n        Friction\n\n        Apply friction to the current value\n        TODO: Make this framerate-independent\n    */\n    friction: function (value, duration) {\n        var newVelocity = speedPerFrame(value.velocity, duration) * (1 - value.friction);\n\n        return calc.speedPerSecond(newVelocity, duration);\n    },\n\n    spring: function (value, duration) {\n        var distance = value.to - value.current;\n\n        value.velocity += distance * speedPerFrame(value.spring, duration);\n        \n        return simulations.friction(value, duration);\n    },\n\n    bounce: function (value) {\n        var distance = 0,\n            to = value.to,\n            current = value.current,\n            bounce = value.bounce;\n        \n        // If we're using glide simulation we have to flip our target too\n        if (value.simulate === 'glide') {\n            distance = to - current;\n            value.to = current - (distance * bounce);\n        }\n        \n        return value.velocity *= - bounce;\n    },\n\n    capture: function (value, target) {\n        value.to = target;\n        value.simulate = 'spring';\n        value.capture = value.min = value.max = undefined;\n    }\n};\n\nmodule.exports = simulations;\n\n\n\n/** WEBPACK FOOTER **\n ** ./src/actions/simulate/simulations.js\n **/","\"use strict\";\n\nvar Input = require('./Input.js'),\n    currentPointer, // Sort this out for multitouch\n    \n    TOUCHMOVE = 'touchmove',\n    MOUSEMOVE = 'mousemove',\n\n    /*\n        Convert event into point\n        \n        Scrape the x/y coordinates from the provided event\n        \n        @param [event]: Original pointer event\n        @param [boolean]: True if touch event\n        @return [object]: x/y coordinates of event\n    */\n    eventToPoint = function (event, isTouchEvent) {\n        var touchChanged = isTouchEvent ? event.changedTouches[0] : false;\n        \n        return {\n            x: touchChanged ? touchChanged.clientX : event.pageX,\n            y: touchChanged ? touchChanged.clientY : event.pageY\n        };\n    },\n    \n    /*\n        Get actual event\n        \n        Checks for jQuery's .originalEvent if present\n        \n        @param [event | jQuery event]\n        @return [event]: The actual JS event  \n    */\n    getActualEvent = function (event) {\n        return event.originalEvent || event;\n    },\n\n    \n    /*\n        Pointer constructor\n    */\n    Pointer = function (e) {\n        var event = getActualEvent(e), // In case of jQuery event\n            isTouch = (event.touches) ? true : false,\n            startPoint = eventToPoint(event, isTouch);\n        \n        this.update(startPoint);\n        this.isTouch = isTouch;\n        this.bindEvents();\n    },\n    \n    proto = Pointer.prototype = new Input();\n\n/*\n    Bind move event\n*/\nproto.bindEvents = function () {\n    this.moveEvent = this.isTouch ? TOUCHMOVE : MOUSEMOVE;\n    \n    currentPointer = this;\n    \n    document.documentElement.addEventListener(this.moveEvent, this.onMove);\n};\n\n/*\n    Unbind move event\n*/\nproto.unbindEvents = function () {\n    document.documentElement.removeEventListener(this.moveEvent, this.onMove);\n};\n\n/*\n    Pointer onMove event handler\n    \n    @param [event]: Pointer move event\n*/\nproto.onMove = function (e) {\n    var newPoint = eventToPoint(e, currentPointer.isTouch);\n    e = getActualEvent(e);\n    e.preventDefault();\n    currentPointer.update(newPoint);\n};\n\nproto.stop = function () {\n    this.unbindEvents();\n};\n\nmodule.exports = Pointer;\n\n\n/** WEBPACK FOOTER **\n ** ./src/input/Pointer.js\n **/","\"use strict\";\n\nvar theLoop = require('./loop.js'),\n    ProcessManager = function () {\n        this.activeIds = [];\n        this.activeProcesses = {};\n        this.deactivateQueue = [];\n        theLoop.setCallback(this, this.fireActive);\n    };\n    \nProcessManager.prototype = {\n    \n    /*\n        [int]: Used for process ID\n    */\n    processCounter: 0,\n    \n    /*\n        [int]: Number of active processes\n    */\n    activeCount: 0,\n    \n    /*\n        Get the process with a given index\n        \n        @param [int]: Index of process\n        @return [Process]\n    */\n    getProcess: function (i) {\n        return this.activeProcesses[i];\n    },\n    \n    /*\n        Get number of active processes\n        \n        @return [int]: Number of active processes\n    */\n    getActiveCount: function () {\n        return this.activeCount;\n    },\n    \n    /*\n        Get active tokens\n\n        @return [array]: Active tokens\n    */\n    getActive: function () {\n        return this.activeIds;\n    },\n    \n    /*\n        Get the length of the deactivate queue\n        \n        @return [int]: Length of queue\n    */\n    getQueueLength: function () {\n        return this.deactivateQueue.length;\n    },\n    \n    /*\n        Fire all active processes\n        \n        @param [int]: Timestamp of executing frames\n        @param [int]: Time since previous frame\n        @return [boolean]: True if active processes found\n    */\n    fireActive: function (framestamp, elapsed) {\n        var process,\n            activeCount = 0,\n            activeIds = [],\n            i = 0;\n\n        // Purge and check active count before execution\n        this.purge();\n        activeCount = this.getActiveCount();\n        activeIds = this.getActive();\n\n        // Loop through active processes and fire callback\n        for (; i < activeCount; i++) {\n            process = this.getProcess(activeIds[i]);\n\n            if (process) {\n                process.fire(framestamp, elapsed);\n            }\n        }\n\n        // Repurge and recheck active count after execution\n        this.purge();\n        activeCount = this.getActiveCount();\n\n        // Return true if we still have active processes, or false if none\n        return activeCount ? true : false;\n    },\n    \n    /*\n        Register a new process\n        \n        @param [Process]\n        @return [int]: Index of process to be used as ID\n    */\n    register: function () {\n        return this.processCounter++;\n    },\n    \n    /*\n        Activate a process\n        \n        @param [int]: Index of active process\n    */\n    activate: function (process, i) {\n        var queueIndex = this.deactivateQueue.indexOf(i),\n            isQueued = (queueIndex > -1),\n            isActive = (this.activeIds.indexOf(i) > -1);\n\n        // Remove from deactivateQueue if in there\n        if (isQueued) {\n            this.deactivateQueue.splice(queueIndex, 1);\n        }\n\n        // Add to active processes array if not already in there\n        if (!isActive) {\n            this.activeIds.push(i);\n            this.activeProcesses[i] = process;\n            this.activeCount++;\n            theLoop.start();\n        }\n    },\n    \n    /*\n        Deactivate a process\n        \n        @param [int]: Index of process to add to deactivate queue\n    */\n    deactivate: function (i) {\n        var queue = this.deactivateQueue;\n        if (queue.indexOf(i) === -1) {\n            queue.push(i);\n        }\n    },\n    \n    /*\n        Purge the deactivate queue\n    */\n    purge: function () {\n        var queueLength = this.getQueueLength(),\n            activeIdIndex = 0,\n            idToDelete = 0;\n\n        while (queueLength--) {\n            idToDelete = this.deactivateQueue[queueLength];\n            activeIdIndex = this.activeIds.indexOf(idToDelete);\n\n            // If process in active list deactivate\n            if (activeIdIndex > -1) {\n                this.activeIds.splice(activeIdIndex, 1);\n                this.activeCount--;\n                delete this.activeProcesses[idToDelete];\n            }\n        }\n        \n        this.deactivateQueue = [];\n    }\n    \n};\n\nmodule.exports = new ProcessManager();\n\n\n/** WEBPACK FOOTER **\n ** ./src/process/manager.js\n **/","/*\n    Bezier function generator\n        \n    Gaëtan Renaudeau's BezierEasing\n    https://github.com/gre/bezier-easing/blob/master/index.js  \n    https://github.com/gre/bezier-easing/blob/master/LICENSE\n    You're a hero\n    \n    Use\n    \n        var easeOut = new Bezier(.17,.67,.83,.67),\n            x = easeOut(0.5); // returns 0.627...\n*/\n\"use strict\";\n\nvar NEWTON_ITERATIONS = 8,\n    NEWTON_MIN_SLOPE = 0.001,\n    SUBDIVISION_PRECISION = 0.0000001,\n    SUBDIVISION_MAX_ITERATIONS = 10,\n    K_SPLINE_TABLE_SIZE = 11,\n    K_SAMPLE_STEP_SIZE = 1.0 / (K_SPLINE_TABLE_SIZE - 1.0),\n    FLOAT_32_SUPPORTED = (typeof Float32Array !== 'undefined'),\n    \n    a = function (a1, a2) {\n        return 1.0 - 3.0 * a2 + 3.0 * a1;\n    },\n    \n    b = function (a1, a2) {\n        return 3.0 * a2 - 6.0 * a1;\n    },\n    \n    c = function (a1) {\n        return 3.0 * a1;\n    },\n\n    getSlope = function (t, a1, a2) {\n        return 3.0 * a(a1, a2) * t * t + 2.0 * b(a1, a2) * t + c(a1);\n    },\n\n    calcBezier = function (t, a1, a2) {\n        return ((a(a1, a2) * t + b(a1, a2)) * t + c(a1)) * t;\n    },\n    \n    /*\n        Bezier constructor\n    */\n    Bezier = function (mX1, mY1, mX2, mY2) {\n        var sampleValues = FLOAT_32_SUPPORTED ? new Float32Array(K_SPLINE_TABLE_SIZE) : new Array(K_SPLINE_TABLE_SIZE),\n            _precomputed = false,\n    \n            binarySubdivide = function (aX, aA, aB) {\n                var currentX, currentT, i = 0;\n\n                do {\n                    currentT = aA + (aB - aA) / 2.0;\n                    currentX = calcBezier(currentT, mX1, mX2) - aX;\n                    if (currentX > 0.0) {\n                        aB = currentT;\n                    } else {\n                        aA = currentT;\n                    }\n                } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);\n\n                return currentT;\n            },\n        \n            newtonRaphsonIterate = function (aX, aGuessT) {\n                var i = 0,\n                    currentSlope = 0.0,\n                    currentX;\n                \n                for (; i < NEWTON_ITERATIONS; ++i) {\n                    currentSlope = getSlope(aGuessT, mX1, mX2);\n                    \n                    if (currentSlope === 0.0) {\n                        return aGuessT;\n                    }\n                    \n                    currentX = calcBezier(aGuessT, mX1, mX2) - aX;\n                    aGuessT -= currentX / currentSlope;\n                }\n                \n                return aGuessT;\n            },\n            \n            \n            calcSampleValues = function () {\n                for (var i = 0; i < K_SPLINE_TABLE_SIZE; ++i) {\n                    sampleValues[i] = calcBezier(i * K_SAMPLE_STEP_SIZE, mX1, mX2);\n                }\n            },\n            \n            \n            getTForX = function (aX) {\n                var intervalStart = 0.0,\n                    currentSample = 1,\n                    lastSample = K_SPLINE_TABLE_SIZE - 1,\n                    dist = 0.0,\n                    guessForT = 0.0,\n                    initialSlope = 0.0;\n                    \n                for (; currentSample != lastSample && sampleValues[currentSample] <= aX; ++currentSample) {\n                    intervalStart += K_SAMPLE_STEP_SIZE;\n                }\n                \n                --currentSample;\n                \n                dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample+1] - sampleValues[currentSample]);\n                guessForT = intervalStart + dist * K_SAMPLE_STEP_SIZE;\n                \n                initialSlope = getSlope(guessForT, mX1, mX2);\n                \n                // If slope is greater than min\n                if (initialSlope >= NEWTON_MIN_SLOPE) {\n                    return newtonRaphsonIterate(aX, guessForT);\n                // Slope is equal to min\n                } else if (initialSlope === 0.0) {\n                    return guessForT;\n                // Slope is less than min\n                } else {\n                    return binarySubdivide(aX, intervalStart, intervalStart + K_SAMPLE_STEP_SIZE);\n                }\n            },\n            \n            precompute = function () {\n                _precomputed = true;\n                if (mX1 != mY1 || mX2 != mY2) {\n                    calcSampleValues();\n                }\n            },\n            \n            /*\n                Generated function\n                \n                Returns value 0-1 based on X\n            */\n            f = function (aX) {\n                var returnValue;\n\n                if (!_precomputed) {\n                    precompute();\n                }\n                \n                // If linear gradient, return X as T\n                if (mX1 === mY1 && mX2 === mY2) {\n                    returnValue = aX;\n                    \n                // If at start, return 0\n                } else if (aX === 0) {\n                    returnValue = 0;\n                    \n                // If at end, return 1\n                } else if (aX === 1) {\n                    returnValue = 1;\n\n                } else {\n                    returnValue = calcBezier(getTForX(aX), mY1, mY2);\n                }\n                \n                return returnValue;\n            };\n            \n            return f;\n    };\n\nmodule.exports = Bezier;\n\n\n/** WEBPACK FOOTER **\n ** ./src/actions/tween/Bezier.js\n **/","module.exports = function (value) {\n    return (typeof value === 'string') ? value.split(/,\\s*/) : [value];\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/manipulators/split-comma-delimited.js\n **/","module.exports = function (value) {\n    return value.substring(value.indexOf('(') + 1, value.lastIndexOf(')'));\n};\n\n\n/** WEBPACK FOOTER **\n ** ./src/value-types/manipulators/function-break.js\n **/","\"use strict\";\n\nvar positionTerms = require('../../value-types/settings/dictionary').positions,\n    numPositionTerms = positionTerms.length,\n\n    TRANSFORM_PERSPECTIVE = 'transformPerspective',\n    SCALE = 'scale',\n    ROTATE = 'rotate',\n    terms = {\n        funcs: ['translate', SCALE, ROTATE, 'skew', TRANSFORM_PERSPECTIVE],\n        props: {} // objects are faster at direct lookups\n    };\n\n// Create transform terms\n(function () {\n    var funcs = terms.funcs,\n        props = terms.props,\n        numFuncs = funcs.length,\n        i = 0,\n\n        createProps = function (funcName) {\n            var j = 0;\n\n            for (; j < numPositionTerms; j++) {\n                props[funcName + positionTerms[j]] = true;\n            }\n        };\n    \n    // Manually add skew and transform perspective  \n    props[ROTATE] = props[SCALE] = props[TRANSFORM_PERSPECTIVE] = true;\n    \n    // Loop over each function name and create function/property terms\n    for (; i < numFuncs; i++) {\n        createProps(funcs[i]);\n    }\n})();\n\nmodule.exports = terms;\n\n\n/** WEBPACK FOOTER **\n ** ./src/roles/css/transform-dictionary.js\n **/","let Action = require('./Action'),\n    calc = require('../inc/calc'),\n\n    STRING = 'string',\n    \n    /*\n        Translate our mapLink value into mapTo\n        \n        @param [number]: Calculated value from linked value\n        @param [Value || object]: Linked value or empty object if we're linking to input\n        @param [array]: List of numbers relating to linked value\n        @param [array]: List of numbers relating to this value\n    */\n    findMappedValue = function (newValue, linkedValue, toValue, mapLink, mapTo) {\n        var mapLength = mapLink.length,\n            i = 1,\n            lastLinkValue,\n            thisLinkValue,\n            lastToValue,\n            thisToValue;\n\n        for (; i < mapLength; i++) {\n            // Assign values from array, or if they're strings, look for them in linkedValue\n            lastLinkValue = (typeof mapLink[i - 1] === STRING) ? linkedValue[mapLink[i - 1]] : mapLink[i - 1];\n            thisLinkValue = (typeof mapLink[i] === STRING) ? linkedValue[mapLink[i]] : mapLink[i];\n            lastToValue = (typeof mapTo[i - 1] === STRING) ? toValue[mapTo[i - 1]] : mapTo[i - 1];\n            thisToValue = (typeof mapTo[i] === STRING) ? toValue[mapTo[i]] : mapTo[i];\n\n            // Check if we've gone past our calculated value, or if we're at the end of the array\n            if (newValue < thisLinkValue || i === mapLength - 1) {\n                newValue = calc.value(calc.restricted(calc.progress(newValue, lastLinkValue, thisLinkValue), 0, 1), lastToValue, thisToValue);\n                break;\n            }\n        }\n        \n        return newValue;\n    };\n\nclass Watch extends Action {\n    constructor(...args) {\n        super(...args);\n        this.isActive = true;\n    }\n\n    /*\n        Process this value\n        \n        First check if this value exists as a Value, if not\n        check within Input (if we have one)\n            \n        @param [Actor]\n        @param [Value]: Current value\n        @param [string]: Key of current value\n        @return [number]: Calculated value\n    */\n    process(actor, value, key) {\n        var values = actor.values,\n            newValue = value.current,\n            watchedKey = value.watch,\n            watchedValue = values[watchedKey] ? values[watchedKey] : {},\n            inputOffset = value.action ? value.action.inputOffset : false;\n\n        // First look at Action and check value isn't linking itself\n        if (watchedValue.current !== undefined && key !== watchedKey) {\n            newValue = watchedValue.current;\n        \n        // Then check values in Input\n        } else if (inputOffset && inputOffset.hasOwnProperty(watchedKey)) {\n            newValue = value.action.process(actor, value, watchedKey);\n        }\n\n        // If we have mapFrom and mapTo properties, translate the new value\n        if (value.mapFrom && value.mapTo) {\n            value.unmapped = newValue;\n            newValue = findMappedValue(newValue, watchedValue, value, value.mapFrom, value.mapTo);\n        }\n\n        return newValue;\n    }\n}\n\nmodule.exports = Watch;\n\n\n/** WEBPACK FOOTER **\n ** ./src/actions/Watch.js\n **/","/*\n    The loop\n*/\n\"use strict\";\n\nvar Timer = require('./timer.js'),\n    tick = require('./tick.js'),\n    Loop = function () {\n        this.timer = new Timer();\n    };\n    \nLoop.prototype = {\n    \n    /*\n        [boolean]: Current status of animation loop\n    */\n    isRunning: false,\n    \n    /*\n        Fire all active processes once per frame\n    */\n    frame: function () {\n        var self = this;\n\n        tick(function (framestamp) {\n            self.timer.update(framestamp);\n            let isActive = self.callback.call(self.scope, framestamp, self.timer.getElapsed());\n\n            if (isActive) {\n                self.frame();\n            } else {\n                self.stop();\n            }\n        });\n    },\n    \n    /*\n        Start loop\n    */\n    start: function () {\n        // Make sure we're not already running a loop\n        if (!this.isRunning) {\n            this.timer.clock();\n            this.isRunning = true;\n            this.frame();\n        }\n    },\n    \n    /*\n        Stop the loop\n    */\n    stop: function () {\n        this.isRunning = false;\n    },\n    \n    /*\n        Set the callback to run every frame\n        \n        @param [Object]: Execution context\n        @param [function]: Callback to fire\n    */\n    setCallback: function (scope, callback) {\n        this.scope = scope;\n        this.callback = callback;\n    }\n \n};\n\nmodule.exports = new Loop();\n\n\n/** WEBPACK FOOTER **\n ** ./src/process/loop.js\n **/","\"use strict\";\n\nvar utils = require('../inc/utils.js'),\n\n    maxElapsed = 33,\n    Timer = function () {\n        this.elapsed = 16.7;\n        this.current = utils.currentTime();\n        this.update();\n    };\n\nTimer.prototype = {\n    update: function (framestamp) {\n        this.prev = this.current;\n        this.current = framestamp;\n        this.elapsed = Math.min(this.current - this.prev, maxElapsed);\n\n        return this.current;\n    },\n\n    getElapsed: function () {\n        return this.elapsed;\n    },\n    \n    clock: function () {\n        this.current = utils.currentTime();\n    }\n};\n\nmodule.exports = Timer;\n\n\n/** WEBPACK FOOTER **\n ** ./src/process/timer.js\n **/","\"use strict\";\n/*\n    requestAnimationFrame polyfill\n    \n    For IE8/9 Flinstones\n\n    Taken from Paul Irish. We've stripped out cancelAnimationFrame checks because we don't fox with that\n    \n    http://paulirish.com/2011/requestanimationframe-for-smart-animating/\n    http://my.opera.com/emoller/blog/2011/12/20/requestanimationframe-for-smart-er-animating\n     \n    requestAnimationFrame polyfill by Erik Möller. fixes from Paul Irish and Tino Zijdel\n     \n    MIT license\n*/\nvar tick,\n    lastTime = 0,\n    hasWindow = (typeof window !== 'undefined');\n\nif (!hasWindow) {\n    // Load rAF shim\n    tick = function (callback) {\n        var currTime = new Date().getTime(),\n            timeToCall = Math.max(0, 16 - (currTime - lastTime)),\n            id = setTimeout(function () {\n                callback(currTime + timeToCall);\n            }, timeToCall);\n\n        lastTime = currTime + timeToCall;\n        \n        return id;\n    };  \n    \n} else {\n    tick = window.requestAnimationFrame;\n}\n\nmodule.exports = tick;\n\n\n/** WEBPACK FOOTER **\n ** ./src/process/tick.js\n **/"],"sourceRoot":"","file":"popmotion.global.js"}