Added bower.json
1.10.0

- Added new Draggable class (in the "utils" package) that makes it simple to make almost any element draggable or spinnable, and impose bounds and (if you have ThrowPropsPlugin) apply kinetic-based motion.

- Added new "addPause()" method to TimelineLite that allows you to insert a pause action that will force calibration of the time at that exact spot and optionally call another method.

- Altered the order of operation in 3D CSS transforms so that scaleX and scaleY occur before rotation instead of after, thus they appear to always stay oriented with the element itself (this is the more common and intuitive behavior).

- Fixed issue that could cause a timeline to render things incorrectly if it was paused and seeked to an earlier time and then resumed (regression since 1.9.2)

- Fixed issue that could cause a security error if "window" was used as the target of a tween from within an iframe.

- Fixed autoAlpha issue in IE8 that could cause a flicker (the bug was actually in IE8 but we implemented a workaround)

- Fixed issue that could prevent tweening the css border of an <img> when autoCSS was used

- Fixed TweenMax.pauseAll() and TweenMax.resumeAll() so that the default "timelines" parameter is true instead of false.

- Small speed improvements for 3D transforms

- Now if you clearProps:"all", it will wipe all transform data stored in _gsTransforms
1.10.0 (patch)

Quick fix of the new addPause() method of TimelineLite (missing a parameter)
1.10.1

- Fixed issue that could cause the last tween in a TweenMax.staggerTo() not to swap in the tween instance for "{self}" in the onCompleteParams when an onCompleteAll was defined.

- Fixed an issue in AttrPlugin that could cause an error if the starting and ending values of the tween are identical.

- Fixed an issue in CSSPlugin that could cause the scaleZ not to be applied correctly in 3D transforms.

- Added a "force3D" boolean special property for CSSPlugin that, when true, applies a 3D transform which typically causes the browser to promote that element to its own layer on the GPU when possible (this can improve performance).

- Fixed an issue in KineticPlugin that could cause directional rotation values not to work after the first time.

- Changed the behavior of TextPlugin from() tweens so that it is more intuitive in terms of the direction.

- The _addTween() method of TweenPlugin now returns the PropTween instance if one is created (or null if not). This can help optimize some other code.

- Minor optimizations
1.10.2

- Added TweenMax.globalTimeScale() method for getting/setting the global time scale (often it's better to use TimelineLite.exportRoot(), though, so please see docs).

- Added a workaround for the iOS bug that sometimes neglects to call the requestAnimationFrame callback when returning to a tab that had been inactive (browser bug, not GSAP), causing animations to cease when returning to that tab.

- Fixed issue that could cause tweens in a nested TimelinLite or TimelineMax not to render their beginning states correctly when the virtual playhead of the grandparent is moved backwards beyond the starting point of the parent timeline.

- Altered autoAlpha behavior in CSSPlugin so that instead of explicitly setting visibility to "visible" when opacity isn't zero, it now sets it to "inherit" so that behaves more intuitively when it has an ancestor whose visibility is "hidden" (the descendent should honor that)

- Fixed an issue that could cause fromTo() tweens not to render their initial state correctly when the "from" value is relative (has a "+=" or "-=" prefix).

- Added "scroll", "scrollTop", and "scrollLeft" types to Draggable and improved performance.

- Minor performance improvements
Draggable 0.7.0

- Added new "trigger" functionality for defining a child element that serves as the initiator of dragging.

- Worked around several bugs in the stock browser of several Android devices.

- Improved performance by shifting rendering from mousemove/touchmove event handlers to the main requestAnimationFrame loop that drives GSAP.

- Improved algorithm for sensing the velocity of the user's mouse/touch.

- Fixed an issue that caused an error when the Draggable JS file was loaded BEFORE the <body> tag was declared.
1.10.3

- Significant update to Draggable (changes listed below)

- Added new "endX", "endY",  "pointerX" and "pointerY" properties to Draggable

- Renamed Draggable's xMax, xMin, yMax, and yMin properties to maxX, minX, maxY, and minY in order to be consistent with the other new properties like endX, pointerX, etc.

- Added a new applyBounds() and update() methods to Draggable

- Added the ability to have rotated elements work with bounds in Draggable

- Added new onThrowComplete and onThrowUpdate callbacks in Draggable

- Added new Draggable.get() method that allows you to find the Draggable instance associated with a particular element.

- Now the Draggable's x and y properties auto-update over the course of the throwProps tween by default.

- New "tween" property that refers to the actual TweenLite instance that’s generated by ThrowPropsPlugin when the mouse/touch is released.

- Worked around bug in IE9 that could cause a Draggable with type:"rotation" to use the top center as the default transformOrigin instead of the true center.

- Now when a link is clicked/tapped, the event's preventDefault() won't be called (so that the link will work) in Draggable.

- Various minor bug fixes and improvements in Draggable

----

- Fixed issue that could cause clearProps not to affect transformOrigin

- Improved compatibility with IE8's AlphaImageLoader filter so that it can be used in some cases to avoid the black edges on transparent PNGs.

- Fixed issue that could ignore transformPerspective when no rotation or skew was involved in the transform

- Added "frame" support in EaselPlugin (to tween the frame number of a MovieClip)

- Improved handling of situations where a tween/timeline is added to a timeline that was already finished (it needs to resume playback intuitively).

- Fixed an issue that could cause a timeline's rawTime() to be reported incorrectly in a very rare situation.
1.11.0

General:
--------

- Added isActive() method to all animation classes (TweenLite, TweenMax, TimelineLite, and TimelineMax)

- Added progress() and totalProgress() methods to TweenLite (they were already available in TweenMax, TimelineLite, and TimelineMax)

- Added a new "onlyActive" parameter to the getTweensOf() and killTweensOf() methods so that it's easy to find (or kill) only the active tweens of a particular target/element/object.

- Worked around an issue with the way browsers handle the "instanceof Array" evaluation in iframes that could cause the condition to return false when it should be true

- Fixed several issues that could cause zero-duration tweens inside timelines to render incorrectly in very particular (and rare) scenarios

- Adjusted behavior of callbacks (and zero-duration tweens) in timelines so that if the playhead moves directly on top of the callback/tween when suppressEvents is true, it will execute callbacks on the following render (when the playhead leaves that spot). So callbacks will get triggered EITHER when the playhead arrives OR when it leaves that spot (not both).

- Now if TweenLite is loaded more than once, only the first will matter (subsequent loads will basically be ignored) in terms of class definition.

Plugins:
----------

- Changed from storing "rotation" (and skewX/skewY) as radians to degrees in _gsTransform for better consistency.

- Fixed issue that could cause a relative opacity value not to work ("+=" or "-=" prefix)

- Worked around IE8 issue that could cause a className tween to throw an error in a rare circumstance.

- Added "userSelect" support (with automatic vendor prefixing)

- Fixed issue that could cause clearProps to get applied at the beginning of a from() tween in addition to at the end (it should only occur at the end).

- Fixed issue that could cause the "max" property not to be calculated properly on a scrollTo tween if the target was the window.

Draggable:
----------

- Windows 8 touch compatible

- There's a new "liveSnap" feature that you can turn on by setting liveSnap:true - that causes any snapping rules to apply during the drag (without liveSnap:true, snapping only applies to the END value(s)). This can be useful if, for example, you want to drag a box that always must fit in a grid or you want to rotate something in 10-degree increments (or whatever).

- You can specifically define maximum and minimum x/y/rotation values for bounds, like bounds:{minX:10, maxX:200, minY:20, maxY:300}. It will also recognize "maxRotation" and "minRotation", like bounds:{maxRotation:90, minRotation:-90}. This is a new option; you can still define bounds the old way instead with either a DOM element (like bounds:"#myElementID") or a generic object with top/left/width/height properties (like bounds:{top:10, left:20, width:100, height:200}). The new maxX/minX/maxY/minY technique is useful if, for example, you have an element that should be able to move 200 pixels to the left but you don't necessarily know its starting position.

- New "rotation", "endRotation", "maxRotation", and "minRotation" properties (which are identical to "x", "endX", "maxX" and "minX" but named more intuitively). It shouldn't break existing code because x/endX/maxX/minX are still populated in the same way. It just seemed like code would be more readable this way when the Draggable type is "rotation".

- Rotation is now always degree-based instead of radian-based. (this also applies to the data stored in the undocumented _gsTransform object in case you're tapping into that)

- There's a new "dragResistance" property (a value between 0 and 1) that controls how much resistance there is during any dragging (not just outside the bounds which is what edgeResistance affects).

- "resistance" has been renamed "throwResistance" so that it's more descriptive (now that we have edgeResistance and dragResistance, it seemed like plain "resistance" was just too vague).

- There's a new "pointerEvent" property that records the last mouse (or touch) event that affected the Draggable instance. That way, you can access that event's data like target, currentTarget, pageX, pageY, etc. By default, that event is also passed as a parameter to callbacks like onDragStart, onDrag, and onDragEnd.

- Added startDrag() and endDrag() methods so that you can manually trigger those, but please note that you MUST pass a mouse (or touch) event as a parameter to those because it's imperative for them to be able to do things like get the pageX and pageY for the mouse/touch position, and preventDefault(), etc.

- <a> links, input fields, textareas, buttons, and  elements with an "onclick" are all treated like live elements that should allow click interaction instead of initiating dragging, plus you can manually mark something as "clickable" by adding a data-clickable="true" attribute.

- A few minor bug fixes.
updated bower.json
Draggable 0.9.4 Update

- Fixed regression in 0.9.3 that caused <span> elements not to be draggable unless you added data-clickable="false" to the element as an attribute or put dragClickables:true on your Draggable.

- Improved idle performance by only activating the "tick" listener the first time an element is clicked/touched and then deactivated the listener after 15 seconds of inactivity.

- Added "newBounds" parameter to applyBounds() method so that you can [optionally] define a new bounds object/element.

- Added onThrowUpdateParams and onThrowCompleteParams.
1.11.1

- Fixed issue that could cause a callback (or zero-duration tween) not to render correctly the 2nd time if seek() is called on its parent timeline from within that same callback (rare, but possible).

- Fixed issue that could cause text selection to remain disabled on the target element of a Draggable after its disable() method is invoked.
1.11.2

- Added new "lockAxis" feature to Draggable that [optionally] automatically locks dragging to either the horizontal or vertical axis (depending on the direction that the user begins dragging)

- Improved IE11 compatibility with Draggable (previously clicks/touches were intermittently ignored in IE11 only).

- Fixes regression that prevented the core ticker from powering down after no tweens are active (just to save some CPU cycles).

- Fixed issue that could cause a percentage-based css tween to measure as if the target is absolutely positioned even if it's not.

- Worked around a bug in the Firefox browser related to animating a 32-bit PNG from a scale of 0 in which case the transparent areas got rendered as black on the Mac.

- Worked around a bug in the Firefox browser that caused thin broken black borders on elements whose transform had a perspective applied but no other 3D-related transforms like z, rotationX, or rotationY.

- Fixed an issue that could cause a backgroundPosition css tween not to render its initial position correctly in Firefox.
Fixed bower.json quote
bower.json update
1.11.3

- Enhanced Draggable so that it can accommodate elements that are nested inside ancestor elements that have transforms applied (like scale, rotation, etc.). The only caveat is that it's best to not have bounds that are rotated differently than the target element.

- Fixed issue that could cause a Draggable not to apply its "snap" if the user throws the target, then interrupts it before movement stops, and then doesn't move the mouse/touch more than 3 pixels before releasing (rare, I know).

- Changed behavior of Draggable's disable() method so that it doesn't remove the instance from the internal lookup table, thus you could still Draggable.get("#yourID") and it'd work. Also added a  kill() method that DOES remove it from the internal lookup table, releasing it for garbage collection.

- Fixed minor issue with TweenMax.updateTo() that could cause it not to reset the duration if the tween had completed or was killed.

- Fixed issue that could cause a zero-duration tween or callback not to fire if its parent timeline's playhead was moved directly on top of it more than once in the same "tick".

- Now the TimelineLite/Max stagger methods copy its smoothChildTiming property to the sub-timeline to avoid behavioral differences in parent/child. (This was only an issue if you specifically set the TimelineLite/Max's smoothChildTiming to true)

- Fixed a floating point rounding error that [in EXTREMELY rare situations] could cause zero-duration tweens at the very beginning of a timeline not to render properly when the playhead is returned to the very beginning after having played through.

- Fixed issue in the tweenTo() and tweenFromTo() methods of TimelineLite/Max that could cause a manual change to the duration of the resulting tween not to be honored.

- Made the default lineHeight suffix of CSSPlugin blank

- Fixed issue that could cause a 3D transforms tween to revert to 2D if you create a 2D tween on an element, then a 3D transform tween on the same element, and the 2D one ends later than the 3D one. For example, an infinitely repeating pulsating scale tween and then a quick rotationY tween (only if force3D wasn't true).

- The "scale" shortcut for CSSPlugin no longer affects scaleZ. It should only affect scaleX and scaleY.

- Fixed a CSSPlugin issue that caused percentages to be capped at 100% when a unit conversion was necessary between the from and to values. For example, 80px to 130%.

- Fixed issue that caused null targets to be interpreted as arrays.

- Fixed issue that could cause a zero-duration tween to be overwritten if it is positioned exactly at the start time of another tween of the same target.

- Fixed issue that could cause an onUpdate not to fire for a zero-duration tween.
Minor updates (fixes) to Draggable and ScrollToPlugin

- Fixed issue that could cause an error if disable() was called more than once on a Draggable of type:"scroll".

- Fixed an issue that could cause ScrollToPlugin to kill a tween if the destination scrollTo value exceeds the maximum scrollTop or scrollLeft of the element.

- Fixed an issue that could prevent a scrollTo tween from overwriting correctly.
1.11.4

- Fixed issue that could prevent transforms from working in Opera if force3D was set to true (regression in 1.11.3)

- Worked around a browser bug affecting Draggable that could cause bounds to be imposed incorrectly (making the target element jump) in a particular scenario.

- Fixed an issue in ScrollToPlugin that could cause a tween to get killed when the maximum scroll value was reached (only if the destination value exceeded the maximum scroll amount).

- Updated KineticPlugin to work with KineticJS 5.0.0 (which means it is not compatible with earlier versions, since KineticJS introduced significant API changes in 5.0.0)

- Worked around Firefox bug that could prevent borderWidth from animating (only if it wasn't defined inline on the element)

- Updated copyright dates
Change to work in grunt build system
Changed reference
Merge branch 'master' of github.com:MassRelevance/GreenSock-JS

Conflicts:
	src/uncompressed/TweenLite.js