function registerSequence(args) {
    if (isPlainObject(args[0])) {
        for (var name in args[0]) {
            if (args[0].hasOwnProperty(name)) {
                registerSequence([name, args[0][name]]);
            }
        }
    } else if (isString(args[0])) {
        var _name = args[0],
            sequence = args[1];
        if (!isString(_name)) {
            console.warn("VelocityJS: Trying to set 'registerSequence' name to an invalid value:", _name);
        } else if (!isPlainObject(sequence)) {
            console.warn("VelocityJS: Trying to set 'registerSequence' sequence to an invalid value:", _name, sequence);
        } else {
            if (SequencesObject[_name]) {
                console.warn("VelocityJS: Replacing named sequence:", _name);
            }
            var percents = {},
                steps = new Array(100),
                properties = [],
                sequenceList = SequencesObject[_name] = {},
                duration = validateDuration(sequence.duration);
            sequenceList.tweens = {};
            if (isNumber(duration)) {
                sequenceList.duration = duration;
            }
            for (var part in sequence) {
                if (sequence.hasOwnProperty(part)) {
                    var keys = String(part).match(rxPercents);
                    if (keys) {
                        var _iteratorNormalCompletion = true;
                        var _didIteratorError = false;
                        var _iteratorError = undefined;

                        try {
                            for (var _iterator = keys[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                                var key = _step.value;

                                var percent = key === "from" ? 0 : key === "to" ? 100 : parseFloat(key);
                                if (percent < 0 || percent > 100) {
                                    console.warn("VelocityJS: Trying to use an invalid value as a percentage (0 <= n <= 100):", _name, percent);
                                } else if (isNaN(percent)) {
                                    console.warn("VelocityJS: Trying to use an invalid number as a percentage:", _name, part, key);
                                } else {
                                    if (!percents[String(percent)]) {
                                        percents[String(percent)] = [];
                                    }
                                    percents[String(percent)].push(part);
                                    for (var property in sequence[part]) {
                                        if (!properties.includes(property)) {
                                            properties.push(property);
                                        }
                                    }
                                }
                            }
                        } catch (err) {
                            _didIteratorError = true;
                            _iteratorError = err;
                        } finally {
                            try {
                                if (!_iteratorNormalCompletion && _iterator.return) {
                                    _iterator.return();
                                }
                            } finally {
                                if (_didIteratorError) {
                                    throw _iteratorError;
                                }
                            }
                        }
                    }
                }
            }
            var orderedPercents = Object.keys(percents).sort(function (a, b) {
                var a1 = parseFloat(a),
                    b1 = parseFloat(b);
                return a1 > b1 ? 1 : a1 < b1 ? -1 : 0;
            });
            orderedPercents.forEach(function (key) {
                steps.push.apply(percents[key]);
            });
            var _iteratorNormalCompletion2 = true;
            var _didIteratorError2 = false;
            var _iteratorError2 = undefined;

            try {
                for (var _iterator2 = properties[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                    var _property = _step2.value;

                    var parts = [],
                        propertyName = camelCase(_property);
                    var _iteratorNormalCompletion3 = true;
                    var _didIteratorError3 = false;
                    var _iteratorError3 = undefined;

                    try {
                        for (var _iterator3 = orderedPercents[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                            var _key = _step3.value;
                            var _iteratorNormalCompletion6 = true;
                            var _didIteratorError6 = false;
                            var _iteratorError6 = undefined;

                            try {
                                for (var _iterator6 = percents[_key][Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
                                    var _value = _step6.value;

                                    var stepProperties = sequence[_value];
                                    if (stepProperties[propertyName]) {
                                        parts.push(isString(stepProperties[propertyName]) ? stepProperties[propertyName] : stepProperties[propertyName][0]);
                                    }
                                }
                            } catch (err) {
                                _didIteratorError6 = true;
                                _iteratorError6 = err;
                            } finally {
                                try {
                                    if (!_iteratorNormalCompletion6 && _iterator6.return) {
                                        _iterator6.return();
                                    }
                                } finally {
                                    if (_didIteratorError6) {
                                        throw _iteratorError6;
                                    }
                                }
                            }
                        }
                    } catch (err) {
                        _didIteratorError3 = true;
                        _iteratorError3 = err;
                    } finally {
                        try {
                            if (!_iteratorNormalCompletion3 && _iterator3.return) {
                                _iterator3.return();
                            }
                        } finally {
                            if (_didIteratorError3) {
                                throw _iteratorError3;
                            }
                        }
                    }

                    if (parts.length) {
                        var realSequence = findPattern(parts, propertyName);
                        var index = 0;
                        if (realSequence) {
                            var _iteratorNormalCompletion4 = true;
                            var _didIteratorError4 = false;
                            var _iteratorError4 = undefined;

                            try {
                                for (var _iterator4 = orderedPercents[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
                                    var _key2 = _step4.value;
                                    var _iteratorNormalCompletion5 = true;
                                    var _didIteratorError5 = false;
                                    var _iteratorError5 = undefined;

                                    try {
                                        for (var _iterator5 = percents[_key2][Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
                                            var value = _step5.value;

                                            var originalProperty = sequence[value][propertyName];
                                            if (originalProperty) {
                                                if (Array.isArray(originalProperty) && originalProperty.length > 1 && (isString(originalProperty[1]) || Array.isArray(originalProperty[1]))) {
                                                    realSequence[index].easing = validateEasing(originalProperty[1], sequenceList.duration || DEFAULT_DURATION);
                                                }
                                                realSequence[index++].percent = parseFloat(_key2) / 100;
                                            }
                                        }
                                    } catch (err) {
                                        _didIteratorError5 = true;
                                        _iteratorError5 = err;
                                    } finally {
                                        try {
                                            if (!_iteratorNormalCompletion5 && _iterator5.return) {
                                                _iterator5.return();
                                            }
                                        } finally {
                                            if (_didIteratorError5) {
                                                throw _iteratorError5;
                                            }
                                        }
                                    }
                                }
                            } catch (err) {
                                _didIteratorError4 = true;
                                _iteratorError4 = err;
                            } finally {
                                try {
                                    if (!_iteratorNormalCompletion4 && _iterator4.return) {
                                        _iterator4.return();
                                    }
                                } finally {
                                    if (_didIteratorError4) {
                                        throw _iteratorError4;
                                    }
                                }
                            }

                            sequenceList.tweens[propertyName] = realSequence;
                        }
                    }
                }
            } catch (err) {
                _didIteratorError2 = true;
                _iteratorError2 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion2 && _iterator2.return) {
                        _iterator2.return();
                    }
                } finally {
                    if (_didIteratorError2) {
                        throw _iteratorError2;
                    }
                }
            }
        }
    }
}
Used to register a sequence. This should never be called by users
directly, instead it should be called via an action:<br/>
<code>Velocity("registerSequence", ""name", VelocitySequence);</code>