Tweene = function()
	{
	    var _self = this;

	    // used for generate unique identifier for any tweene object (tweens, timelines, callbacks and labels)
	    this._idCounter = 0;

	    // internally, all time values use this unit
	    this._coreTimeUnit = 'ms';

	    // time unit used when pure numbers are passed as delay or duration values. Users can change this value any time
	    // when the user requires only GSAP driver, it defaults to 's' in order to mimic the library native API
	    this.defaultTimeUnit = 'ms';

	    this._macros = {};

	    this.easings = easings;

	    this.durations = durations;

	    this.speeds = speeds;

	    this.defaultDriver = 'jquery';

	    this.defaultEasing = 'easeOutQuad';

	    this.defaultDuration = '400ms';

	    // container for registered drivers
	    var _drivers = {
	            tween: {},
	            timeline: {}
	        },


	        /**
	         * Create a tween or timeline object of the specified driver. If driverName is not given, it fallbacks to default driver
	         *
	         * @param {string} 'tween' or 'timeline'
	         * @param {string} [driverName] - one of the registered driver's name
	         * @returns {object} tween or timeline object
	         */
	        _getInstance = function(type, driverName)
	        {
	            var d, i;
	            driverName = (driverName? driverName : _self.defaultDriver).toLowerCase();

	            if(driverName in _drivers[type])
	            {
	                d = _drivers[type][driverName];
	                i = new d();
	                i.driverName = driverName;
	                return i;
	            }
	            throw 'Driver ' + name + ' not found';
	        },


	        /**
	         * Common method used inside from(), to() and fromTo() to create a tween and pass arguments to it
	         *
	         * @param {arguments} args - list of arguments passed to original public method
	         * @param {string} method - 'from' | 'to' | 'fromTo'
	         * @returns {object} - return a tween object
	         */
	        _tweenNow = function(args, method)
	        {
	            var tw = _getInstance('tween');
	            if(args.length)
	            {
	                args = toArray(args, 0);
	                tw.target(args.shift())[method].apply(tw, args);
	            }

	            return tw._immediateStart? tw.play() : tw;
	        };


	    /**
	     * Register an animation driver
	     *
	     * @param {string} name - name of the driver
	     * @param {string} type - 'tween' | 'timeline'
	     * @param {function} construct - constructor function that defines the driver class
	     * @returns {Tweene}
	     */
	    this.registerDriver = function(name, type, construct)
	    {
	        type = type.toLowerCase();
	        if(type != 'tween')
	        {
	            type = 'timeline';
	        }
	        _drivers[type][name.toLowerCase()] = construct;
	        return this;
	    };


	    /**
	     * Define a macro for tween objects
	     * @link http://tweene.com/docs/#macro
	     *
	     * @param {string} name
	     * @param {function} macro - inside the function, 'this' refers to the tween object
	     * @returns {Tweene}
	     */
	    this.registerMacro = function(name, macro)
	    {
	        this._macros[name] = macro;
	        return this;
	    };


	    /**
	     * Return an instance of a tween object
	     * @link http://tweene.com/docs/#createTween
	     *
	     * @param {object|string} [target] jquery object or string selector of the dom element(s) to be animated
	     * @param {string} [driver]
	     * @returns {object}
	     */
	    this.get = function(target, driver)
	    {
	        var t = _getInstance('tween', driver);
	        return target? t.target(target) : t;
	    };


	    /**
	     * Apply instantly the properties values to the target
	     *
	     * @param {object|string} target
	     * @param {object} values - CSS property - value map
	     * @returns {unresolved}
	     */
	    this.set = function(target, values)
	    {
	        return _getInstance('tween').target(target).set(values);
	    };


	    /**
	     * Create a tween object for a 'to' animation and pass the arguments to it. First argument is always the target.
	     * If you don't set paused: true in the options passed, the tween will start immediately.
	     * @link http://tweene.com/docs/#tweenTo
	     *
	     * @returns {object} - return the tween object
	     */
	    this.to = function()
	    {
	        return _tweenNow(arguments, 'to');
	    };


	    /**
	     * Create a tween object for a 'from' animation and pass the arguments to it. First argument is always the target.
	     * If you don't set paused: true in the options passed, the tween will start immediately.
	     * @link http://tweene.com/docs/#tweenFrom
	     *
	     * @returns {object} - return the tween object
	     */
	    this.from = function()
	    {
	        return _tweenNow(arguments, 'from');
	    };


	    /**
	     * Create a tween object for a 'fromTo' animation and pass the arguments to it. First argument is always the target.
	     * If you don't set paused: true in the options passed, the tween will start immediately.
	     * @link http://tweene.com/docs/#tweenFromTo
	     *
	     * @returns {object} - return the tween object
	     */
	    this.fromTo = function()
	    {
	        return _tweenNow(arguments, 'fromTo');
	    };


	    /**
	     * Create a timeline object
	     * @link http://tweene.com/docs/#createTimeline
	     *
	     * @param {object|string} [target] - it checks if the object passed as first param is a plain object (options) or not (target)
	     * @param {object} [options]
	     * @param {string} driver - name of the driver
	     * @returns {object} - a timeline object
	     */
	    this.line = function(target, options, driver)
	    {
	        // we assume that targets cannot be plain objects
	        var lineTarget = (isObject(target) && !seemsPlainObject(target))  || isString(target)? target : null;
	        // if no target is passed, unshift arguments by one position
	        if(!lineTarget)
	        {
	            options = arguments[0];
	            driver = arguments[1];
	        }
	        options = seemsPlainObject(options)? options : {};
	        // driver can be specified also with a 'driver' property inside options object
	        driver = (driver !== void 0)? driver : 'driver' in options? options.driver : null;
	        return _getInstance('timeline', driver)
	            .options(options)
	            .target(lineTarget);
	    };

	}
Tweene global class, is the unique identifier exported

You will never need to instantiate a Tweene object. You have to use Tweene static methods
in order to obtain instances of tween and timeline objects of the different drivers

@class