function registerNormalization(args) {
    var constructor = args[0],
        name = args[1],
        callback = args[2];
    if (isString(constructor) && !(window[constructor] instanceof Object) || !isString(constructor) && !(constructor instanceof Object)) {
        console.warn("VelocityJS: Trying to set 'registerNormalization' constructor to an invalid value:", constructor);
    } else if (!isString(name)) {
        console.warn("VelocityJS: Trying to set 'registerNormalization' name to an invalid value:", name);
    } else if (!isFunction(callback)) {
        console.warn("VelocityJS: Trying to set 'registerNormalization' callback to an invalid value:", name, callback);
    } else {
        var index = constructors.indexOf(constructor),
            nextArg = 3;
        if (index < 0 && !isString(constructor)) {
            if (constructorCache.has(constructor)) {
                index = constructors.indexOf(constructorCache.get(constructor));
            } else {
                for (var property in window) {
                    if (window[property] === constructor) {
                        index = constructors.indexOf(property);
                        if (index < 0) {
                            index = constructors.push(property) - 1;
                            Normalizations[index] = {};
                            constructorCache.set(constructor, property);
                        }
                        break;
                    }
                }
            }
        }
        if (index < 0) {
            index = constructors.push(constructor) - 1;
            Normalizations[index] = {};
        }
        Normalizations[index][name] = callback;
        if (isString(args[nextArg])) {
            var unit = args[nextArg++];
            var units = NormalizationUnits[unit];
            if (!units) {
                units = NormalizationUnits[unit] = [];
            }
            units.push(callback);
        }
        if (args[nextArg] === false) {
            NoCacheNormalizations.add(name);
        }
    }
}
Used to register a normalization. This should never be called by users
directly, instead it should be called via an action:<br/>
<code>Velocity("registerNormalization", "Element", "name", VelocityNormalizationsFn[, false]);</code>

The second argument is the class of the animatable object. If this is passed
as a class name (ie, `"Element"` -> `window["Element"]`) then this will work
cross-iframe. If passed as an actual class (ie `Element`) then it will
attempt to find the class on the window and use that name instead. If it
can't find it then it will use the class passed, which allows for custom
animation targets, but will not work cross-iframe boundary.

The fourth argument can be an explicit <code>false</code>, which prevents
the property from being cached. Please note that this can be dangerous
for performance!