polymer-paper-rails 0.1.0 → 0.2.0

data/app/assets/components/web-animations-js/tutorial/tutorial-style.css

@@ -0,0 +1,344 @@
+/**
+ * Copyright 2013 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+ /*TODO:
+ - incorperate object notation (JSON) varibles for the test so it is easier to call
+ */
+
+#main {
+  margin: 100px auto;
+  width: 80%;
+}
+#tryIt {
+  width: 90%;
+  margin: 30px auto;
+  clear: both;
+}
+.heading {
+  background-color: #AFA;
+  border-radius: 10px;
+  padding: 20px;
+  margin: 5px;
+  font: bold 1.2em Arial;
+  height: 25px;
+  clear: both;
+}
+#update {
+  border-radius: 10px;
+  background-color: white;
+  float: right;
+  width: 10%;
+  font: 1em Arial;
+  padding: 3px;
+}
+.code {
+  margin: 0 auto;
+  border-radius: 2px;
+  border: 1px solid black;
+  height: 600px;
+  width: 55%;
+  float: left;
+  overflow: auto;
+}
+#htmlCode {
+  width: 99%;
+  height: 28%;
+  
+}
+#jsCode {
+  width: 99%;
+  height: 28%;
+  overflow-x: hidden;
+}
+#cssCode {
+  width: 99%;
+  height: 28%;
+  float: left;
+  overflow-x: hidden;
+}
+#display {
+  position: relative;
+  height: 100%;
+  width: 100%;
+  float: none;
+}
+.display {
+  border-radius: 2px;
+  width: 44%;
+  height: 600px;
+  clear: right;
+  float: right;
+}
+.label {
+  font: bold 1em Arial;
+  padding: 1%;
+  height: 2%;
+  float: left;
+  clear: both;
+}
+.description {
+  font: 1em sans-serif, "Comic Sans MS", cursive;
+  margin: 10px;
+  clear: both;
+  padding: 10px;
+}
+#title {
+  font: bold 2em Verdana;
+  color: #680;
+  text-align: center;
+  padding: 10px;
+  margin: 2px;
+}
+.content{
+  padding: 3px;
+  width: 80%;
+  margin: 3px auto;
+  text-align: justify;
+}
+.subTitle {
+  background-color: #ABCDEF;
+  padding: 10px; 
+}
+code {
+  color: #94704D;
+  font-size: 1.1em;
+}
+.exercises {
+  font: bold 1em "Lucida Sans Unicode", "Lucida Grande", sans-serif;
+  background: #FFFF00;
+  width: 30%;
+  float: left;
+  padding: 10px;
+  margin: 30px 3px;
+}
+a {
+  text-decoration: none;
+  color: black;
+}
+a:visited {
+  color: black;
+}
+.separator {
+  height: 50px;
+}
+.sideMenu {
+  list-style-type: none;
+  position: absolute;
+  top: 18%;
+  z-index: 0;
+}
+.sideMenu li:hover {
+  background-color: #E6E6E6;
+  color: #222;
+  cursor: pointer
+}
+.sideMenu li {
+  display: block;
+  width: 81%;
+  background-color: #737373;
+  padding: 20px;
+  color: #CCC;
+  border: 1px solid black;
+  z-index: 0;
+}
+.sideMenu li, #alphabet-menu li {
+  font: 1em "Lucida Sans Unicode", "Lucida Grande", sans-serif;
+  z-index: 0;
+}
+#menuLabel {
+  background-color: #222;
+  width: 81%;
+  padding: 20px;
+  color: #DDD;
+}
+#toggleText {
+  width: 60%;
+  display: none;
+  position: relative;
+  float: right;
+  clear: both;
+  font-size: 0.9em;
+  margin-bottom: 10px;
+}
+#toggleText:after {
+  content: '.';
+  clear: both;
+  display: block;
+  height: 0px;
+  text-indent: -999999em;
+}
+.codeSamples {
+  padding: 10px;
+  border: 1px solid black;
+  background-color: #EEE;
+  width: 80%;
+  clear: both;
+  margin-left: 10%;
+  display: block;
+}
+#hideLabel {
+  width: 10%;
+  height: 20px;
+  float: right;
+  background-color: #999999;
+  padding: 5px;
+  margin: 10px;
+  font: 0.8em "Lucida Sans Unicode", "Lucida Grande", sans-serif;
+  color: black;
+  text-align: center;
+  border-radius: 10px;
+  cursor: pointer;
+}
+.topMenu {
+  list-style-type: none;
+  float: left;
+  position: absolute;
+  z-index: 5;
+  top: 0;
+  left: 0;
+  margin: 0;
+}
+.topMenu li {
+  float: left;
+  margin-right: 5px;
+  position: relative;
+}
+.topMenu a {
+  padding: 10px;
+  top: 0px;
+  display: block;
+  background-color: #222;
+  width: 150px;
+  color: #DDD;
+  text-align: center;
+  border: 1px solid black;
+  text-decoration: none;
+  font: 1.1em "Lucida Sans Unicode", "Lucida Grande", sans-serif;
+}
+.topMenu a:hover {
+  background-color: #EEE;
+  color: black;
+}
+.topMenu .subMenu {
+  list-style-type: none;
+  position: absolute;
+  left: -9999px;
+  font-size: 0.8em;
+  z-index: 990;
+}
+.topMenu .subMenu li {
+  padding-top: 1px;
+  float: none;
+  z-index: 1;
+}
+.topMenu .subMenu a {
+  white-space: nowrap;
+  background-color: rgba(34,34,34, 0.1);
+  color: #222;
+  z-index: 1;
+}
+.topMenu li:hover .subMenu {
+  left: -40px;
+  z-index: 1;
+}
+.topMenu .subMenu li:hover a {
+  background-color: rgba(34,34,34,0.9);
+  color: #EEE;
+}
+.line-separator {
+  height: 2px;
+  background: #717171;
+  border-bottom: 1px solid #313030;
+  clear: both;
+}
+.demos {
+  height: 800px;
+  width: 110%;
+  border: 0px;
+}
+#alphabet-menu {
+  list-style-type: none;
+}
+#alphabet-menu a {
+  float: left;
+  padding: 15px;
+  margin-bottom: 10px;
+  display: inline;
+  border: 1px solid white;
+  background-color: #FF3333;
+  color: black;
+  font-weight: bold;
+}
+#alphabet-menu a:hover {
+  background-color: #FFE6E6;
+  color: black;
+}
+.note {
+  color: red;
+  font-size: 0.9em;
+}
+.alphabet-title {
+  float: left;
+  clear: left;
+  width: 100%;
+  font: bold 1.5em "Lucida Sans Unicode", "Lucida Grande", sans-serif;
+  color: #6699FF;
+  margin-top: 10px;
+  border-bottom: 3px dotted #334C80;
+}
+.keywords {
+  color: red;
+}
+.datatype {
+  color: #009933;
+}
+.animViewerText {
+  top: 500px;
+}
+.backToTop {
+  float: right;
+  clear: both;
+  font: 0.6em "Lucida Sans Unicode", "Lucida Grande", sans-serif;
+  color: #6699FF;
+  margin-bottom: 0;
+}
+.content li {
+  line-height: 170%;
+}
+.properties-table {
+  margin: 3% auto;
+  border: 2px solid #EBEBEB;
+  font: 0.9em Georgia, serif;
+}
+.properties-table td {
+  padding: 8px;
+  border-bottom: 2px double #CFCFCF;
+}
+.properties-table-title td {
+  font-weight: bold;
+}
+.pass {
+  background-color: #AFA;
+  border-radius: 10px;
+  padding: 20px;
+  margin: 5px;
+  font: bold 50pt Arial;
+  height: 1em;
+  clear: both;
+  text-align: center;
+}
+.fail {
+  visibility: hidden;
+}

data/app/assets/components/web-animations-js/tutorial/tutorial-testing.js

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2013 Google Inc. All Rights Reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+"use strict";
+
+(function() {
+var pass;
+var completedTests;
+var allDone;
+var numTests;
+
+// Call to initialize the testing environment.
+function setupTutorialTests() {
+  setState("Manual");
+  var timeOfAnimation = document.createElement('div');
+  timeOfAnimation.id = "animViewerText";
+  timeOfAnimation.innerHTML = "Current animation time: 0.00";
+  document.body.appendChild(timeOfAnimation);
+  numTests = 0;
+  completedTests = 0;
+  allDone = false;
+  pass = true;
+}
+
+// This function mimics the async_test function in testharness.js so that
+// extra-asserts.js will run as intended for a tutorial.
+function async_test(func, name, properties) {
+  numTests++;
+  step = function(func) {
+    func();
+    if (!pass) {
+      parent.TryItDisplay.fail();
+      allDone = true;
+    };
+  };
+
+  done = function() {
+    completedTests++;
+    if (completedTests == numTests && !allDone) {
+      allDone = true;
+      parent.TryItDisplay.pass();
+    };
+  };
+  return this;
+}   
+
+function assert_equals(actual, expected, description) {
+  pass = (actual == expected);
+}
+
+function assert_approx_equals(actual, expected, epsilon, description) {
+  var lowerBound = expected - (epsilon / 2) < actual;
+  var upperBound = expected + (epsilon / 2) > actual;
+  pass = (lowerBound && upperBound);
+}
+
+// This function is required to do nothing for tutorial testing,
+// but extra-asserts calls it and thus without this function, 
+// extra-asserts.js will cause the page to crash.
+function add_completion_callback(anything) {
+}
+
+///////////////////////////////////////////////////////////////////////////////
+//  Exposing functions to be accessed externally                             //
+///////////////////////////////////////////////////////////////////////////////
+
+window.setupTutorialTests = setupTutorialTests;
+window.async_test = async_test;
+window.assert_approx_equals = assert_approx_equals;
+window.assert_equals = assert_equals;
+window.add_completion_callback = add_completion_callback;
+})();

data/app/assets/components/{core/animation → web-animations-js}/web-animations.js

@@ -409,7 +409,6 @@ var AnimationPlayer = function(token, source, timeline) {
     this._hasTicked = false;
 
     this.source = source;
-    this._checkForLegacyHandlers();
     this._lastCurrentTime = undefined;
     this._finishedFlag = false;
     initializeEventTarget(this);
@@ -437,7 +436,6 @@ AnimationPlayer.prototype = {
         this._update();
         maybeRestartAnimation();
       }
-      this._checkForLegacyHandlers();
     } finally {
       exitModifyCurrentAnimationState(repeatLastTick);
     }
@@ -691,26 +689,8 @@ AnimationPlayer.prototype = {
       this._lastCurrentTime = 0;
     }
 
-    if (this._needsLegacyHandlerPass) {
-      var timeDelta = this._unlimitedCurrentTime - this._lastCurrentTime;
-      if (timeDelta > 0) {
-        this.source._generateLegacyEvents(
-            this._lastCurrentTime, this._unlimitedCurrentTime,
-            this.timeline.currentTime, 1);
-      }
-    }
-
     this._lastCurrentTime = this._unlimitedCurrentTime;
   },
-  // These two legacy methods are for deprecated TimedItem event handling and
-  // should be removed once we stop supporting it.
-  _legacyHandlerAdded: function() {
-    this._needsLegacyHandlerPass = true;
-  },
-  _checkForLegacyHandlers: function() {
-    this._needsLegacyHandlerPass = this.source !== null &&
-        this.source._hasLegacyEventHandlers();
-  },
   _registerOnTimeline: function() {
     if (!this._registeredOnTimeline) {
       PLAYERS.push(this);
@@ -1096,13 +1076,6 @@ TimedItem.prototype = {
   _hasFutureEffect: function() {
     return this._isCurrent() || this._fill !== 'none';
   },
-  _hasLegacyEventHandlers: function() {
-    return hasEventHandlersForEvent(this, 'start') ||
-        hasEventHandlersForEvent(this, 'iteration') ||
-        hasEventHandlersForEvent(this, 'end') ||
-        hasEventHandlersForEvent(this, 'cancel');
-  },
-  _generateChildLegacyEventsForRange: function() { },
   _toSubRanges: function(fromTime, toTime, iterationTimes) {
     if (fromTime > toTime) {
       var revRanges = this._toSubRanges(toTime, fromTime, iterationTimes);
@@ -1131,151 +1104,9 @@ TimedItem.prototype = {
     }
     ranges.push([currentStart, toTime]);
     return {start: skipped, delta: 1, ranges: ranges};
-  },
-  _generateLegacyEvents: function(fromTime, toTime, globalTime, deltaScale) {
-    function toGlobal(time) {
-      return (globalTime - (toTime - (time / deltaScale)));
-    }
-    var firstIteration = Math.floor(this.timing.iterationStart);
-    var lastIteration = Math.floor(this.timing.iterationStart +
-        this.timing.iterations);
-    if (lastIteration === this.timing.iterationStart +
-        this.timing.iterations) {
-      lastIteration -= 1;
-    }
-    var startTime = this.startTime + this.timing.delay;
-
-    if (hasEventHandlersForEvent(this, 'start')) {
-      // Did we pass the start of this animation in the forward direction?
-      if (fromTime <= startTime && toTime > startTime) {
-        callEventHandlers(this, 'start',
-            new TimingEvent(
-                constructorToken, this, 'start', this.timing.delay,
-                toGlobal(startTime), firstIteration));
-      // Did we pass the end of this animation in the reverse direction?
-      } else if (fromTime > this.endTime && toTime <= this.endTime) {
-        callEventHandlers(this, 'start',
-            new TimingEvent(
-                constructorToken, this, 'start', this.endTime - this.startTime,
-                toGlobal(this.endTime), lastIteration));
-      }
-    }
-
-    // Calculate a list of uneased iteration times.
-    var iterationTimes = [];
-    for (var i = firstIteration + 1; i <= lastIteration; i++) {
-      iterationTimes.push(i - this.timing.iterationStart);
-    }
-    iterationTimes = iterationTimes.map(function(i) {
-      return i * this.duration / this.timing.playbackRate + startTime;
-    }.bind(this));
-
-    // Determine the impacted subranges.
-    var clippedFromTime;
-    var clippedToTime;
-    if (fromTime < toTime) {
-      clippedFromTime = Math.max(fromTime, startTime);
-      clippedToTime = Math.min(toTime, this.endTime);
-    } else {
-      clippedFromTime = Math.min(fromTime, this.endTime);
-      clippedToTime = Math.max(toTime, startTime);
-    }
-    var subranges = this._toSubRanges(
-        clippedFromTime, clippedToTime, iterationTimes);
-
-    for (var i = 0; i < subranges.ranges.length; i++) {
-      var currentIter = subranges.start + i * subranges.delta;
-      if (i > 0 && hasEventHandlersForEvent(this, 'iteration')) {
-        var iterTime = subranges.ranges[i][0];
-        callEventHandlers(this, 'iteration',
-            new TimingEvent(
-                constructorToken, this, 'iteration', iterTime - this.startTime,
-                toGlobal(iterTime), currentIter));
-      }
-
-      var iterFraction;
-      if (subranges.delta > 0) {
-        iterFraction = this.timing.iterationStart % 1;
-      } else {
-        iterFraction = 1 -
-            (this.timing.iterationStart + this.timing.iterations) % 1;
-      }
-      this._generateChildLegacyEventsForRange(
-          subranges.ranges[i][0], subranges.ranges[i][1],
-          fromTime, toTime, currentIter - iterFraction,
-          globalTime, deltaScale * this.timing.playbackRate);
-    }
-
-    if (hasEventHandlersForEvent(this, 'end')) {
-      // Did we pass the end of this animation in the forward direction?
-      if (fromTime < this.endTime && toTime >= this.endTime) {
-        callEventHandlers(this, 'end',
-            new TimingEvent(
-                constructorToken, this, 'end', this.endTime - this.startTime,
-                toGlobal(this.endTime), lastIteration));
-      // Did we pass the start of this animation in the reverse direction?
-      } else if (fromTime >= startTime && toTime < startTime) {
-        callEventHandlers(this, 'end',
-            new TimingEvent(
-                constructorToken, this, 'end', this.timing.delay,
-                toGlobal(startTime), firstIteration));
-      }
-    }
   }
 };
 
-defineDeprecatedProperty(TimedItem.prototype, 'specified', function() {
-  deprecated('specified', '2014-04-16', 'Please use timing instead.');
-  return this.timing;
-});
-var deprecatedTimedItemEvents = function() {
-  deprecated('TimedItem events', '2014-04-22',
-      'Please use the AnimationPlayer finish event instead.', true);
-};
-['start', 'iteration', 'end', 'cancel'].forEach(function(eventName) {
-  defineDeprecatedProperty(TimedItem.prototype, 'on' + eventName,
-      function() {
-        deprecatedTimedItemEvents();
-        return getOnEventHandler(this, eventName);
-      },
-      function(handler) {
-        deprecatedTimedItemEvents();
-        setOnEventHandler(this, eventName, handler);
-        if (this.player) {
-          if (typeof func === 'function') {
-            this.player._legacyHandlerAdded();
-          } else {
-            this.player._checkForLegacyHandlers();
-          }
-        }
-      });
-});
-defineDeprecatedProperty(TimedItem.prototype, 'addEventListener', function() {
-  deprecatedTimedItemEvents();
-  return function(type, handler) {
-    if (type !== 'start' &&
-        type !== 'iteration' &&
-        type !== 'end' &&
-        type !== 'cancel') {
-      return;
-    }
-    addEventHandler(this, type, handler);
-    if (this.player) {
-      this.player._legacyHandlerAdded();
-    }
-  }
-});
-defineDeprecatedProperty(TimedItem.prototype, 'removeEventListener',
-    function() {
-      deprecatedTimedItemEvents();
-      return function(type, handler) {
-        removeEventHandler(this, type, handler);
-        if (this.player) {
-          this.player._checkForLegacyHandlers();
-        }
-      }
-    });
-
 var TimingEvent = function(
     token, target, type, localTime, timelineTime, iterationIndex, seeked) {
   if (token !== constructorToken) {
@@ -1476,10 +1307,6 @@ TimingGroup.prototype = createObject(TimedItem.prototype, {
     // Update child start times before walking down.
     this._updateChildStartTimes();
 
-    if (this.player) {
-      this.player._checkForLegacyHandlers();
-    }
-
     this._isInChildrenStateModified = false;
   },
   _updateInheritedTime: function(inheritedTime) {
@@ -1630,41 +1457,6 @@ TimingGroup.prototype = createObject(TimedItem.prototype, {
     return this.type + ' ' + this.startTime + '-' + this.endTime + ' (' +
         this.localTime + ') ' + ' [' +
         this._children.map(function(a) { return a.toString(); }) + ']';
-  },
-  _hasLegacyEventHandlers: function() {
-    return TimedItem.prototype._hasLegacyEventHandlers.call(this) || (
-        this._children.length > 0 &&
-        this._children.reduce(
-            function(a, b) { return a || b._hasLegacyEventHandlers(); },
-            false));
-  },
-  _generateChildLegacyEventsForRange: function(localStart, localEnd, rangeStart,
-      rangeEnd, iteration, globalTime, deltaScale) {
-    var start;
-    var end;
-
-    if (localEnd - localStart > 0) {
-      start = Math.max(rangeStart, localStart);
-      end = Math.min(rangeEnd, localEnd);
-      if (start >= end) {
-        return;
-      }
-    } else {
-      start = Math.min(rangeStart, localStart);
-      end = Math.max(rangeEnd, localEnd);
-      if (start <= end) {
-        return;
-      }
-    }
-
-    var endDelta = rangeEnd - end;
-    start -= iteration * this.duration / deltaScale;
-    end -= iteration * this.duration / deltaScale;
-
-    for (var i = 0; i < this._children.length; i++) {
-      this._children[i]._generateLegacyEvents(
-          start, end, globalTime - endDelta, deltaScale);
-    }
   }
 });
 
@@ -4593,6 +4385,81 @@ var transformType = {
   }
 };
 
+var pathType = {
+  // Properties ...
+  // - path: The target path element
+  // - points: The absolute points to set on the path
+  // - cachedCumulativeLengths: The lengths at the end of each segment
+  add: function() { throw 'Addition not supported for path attribute' },
+  cumulativeLengths: function(value) {
+    if (isDefinedAndNotNull(value.cachedCumulativeLengths))
+      return value.cachedCumulativeLengths;
+    var path = value.path.cloneNode(true);
+    var cumulativeLengths = [];
+    while (path.pathSegList.numberOfItems > 0) {
+      // TODO: It would be good to skip moves here and when generating points.
+      cumulativeLengths.unshift(path.getTotalLength());
+      path.pathSegList.removeItem(path.pathSegList.numberOfItems - 1);
+    }
+    value.cachedCumulativeLengths = cumulativeLengths;
+    return value.cachedCumulativeLengths;
+  },
+  appendFractions: function(fractions, cumulativeLengths) {
+    ASSERT_ENABLED && assert(cumulativeLengths[0] === 0);
+    var totalLength = cumulativeLengths[cumulativeLengths.length - 1];
+    for (var i = 1; i < cumulativeLengths.length - 1; ++i)
+      fractions.push(cumulativeLengths[i] / totalLength);
+  },
+  interpolate: function(from, to, f) {
+    // FIXME: Handle non-linear path segments.
+    // Get the fractions at which we need to sample.
+    var sampleFractions = [0, 1];
+    pathType.appendFractions(sampleFractions, pathType.cumulativeLengths(from));
+    pathType.appendFractions(sampleFractions, pathType.cumulativeLengths(to));
+    sampleFractions.sort();
+    ASSERT_ENABLED && assert(sampleFractions[0] === 0);
+    ASSERT_ENABLED && assert(sampleFractions[sampleFractions.length - 1] === 1);
+
+    // FIXME: Cache the 'from' and 'to' points.
+    var fromTotalLength = from.path.getTotalLength();
+    var toTotalLength = to.path.getTotalLength();
+    var points = [];
+    for (var i = 0; i < sampleFractions.length; ++i) {
+      var fromPoint = from.path.getPointAtLength(
+          fromTotalLength * sampleFractions[i]);
+      var toPoint = to.path.getPointAtLength(
+          toTotalLength * sampleFractions[i]);
+      points.push({
+        x: interp(fromPoint.x, toPoint.x, f),
+        y: interp(fromPoint.y, toPoint.y, f)
+      });
+    }
+    return {points: points};
+  },
+  pointToString: function(point) {
+    return point.x + ',' + point.y;
+  },
+  toCssValue: function(value, svgMode) {
+    // FIXME: It would be good to use PathSegList API on the target directly,
+    // rather than generating this string, but that would require a hack to
+    // setValue().
+    ASSERT_ENABLED && assert(svgMode,
+        'Path type should only be used with SVG \'d\' attribute');
+    if (value.path)
+      return value.path.getAttribute('d');
+    var ret = 'M' + pathType.pointToString(value.points[0]);
+    for (var i = 1; i < value.points.length; ++i)
+      ret += 'L' + pathType.pointToString(value.points[i]);
+    return ret;
+  },
+  fromCssValue: function(value) {
+    var path = document.createElementNS('http://www.w3.org/2000/svg', 'path');
+    if (value)
+      path.setAttribute('d', value);
+    return {path: path};
+  }
+};
+
 var propertyTypes = {
   backgroundColor: colorType,
   backgroundPosition: positionListType,
@@ -4615,6 +4482,7 @@ var propertyTypes = {
   color: colorType,
   cx: lengthType,
   cy: lengthType,
+  d: pathType,
   dx: lengthType,
   dy: lengthType,
   fill: colorType,
@@ -4693,6 +4561,7 @@ var propertyTypes = {
 var svgProperties = {
   'cx': 1,
   'cy': 1,
+  'd': 1,
   'dx': 1,
   'dy': 1,
   'fill': 1,
@@ -5657,10 +5526,4 @@ window._WebAnimationsTestingUtilities = {
   _propertyIsSVGAttrib: propertyIsSVGAttrib
 };
 
-defineDeprecatedProperty(window, 'Timeline', function() {
-  deprecated('Timeline', '2014-04-08',
-      'Please use AnimationTimeline instead.');
-  return AnimationTimeline;
-});
-
 })();