{"version":3,"sources":["rebound.js","Polygon.js","Spinner.js","demo.js"],"names":[],"mappings":"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","file":"main.js","sourcesContent":["// Rebound\n// =======\n// **Rebound** is a simple library that models Spring dynamics for the\n// purpose of driving physical animations.\n//\n// Origin\n// ------\n// [Rebound](http://facebook.github.io/rebound) was originally written\n// in Java to provide a lightweight physics system for\n// [Home](https://play.google.com/store/apps/details?id=com.facebook.home) and\n// [Chat Heads](https://play.google.com/store/apps/details?id=com.facebook.orca)\n// on Android. It's now been adopted by several other Android\n// applications. This JavaScript port was written to provide a quick\n// way to demonstrate Rebound animations on the web for a\n// [conference talk](https://www.youtube.com/watch?v=s5kNm-DgyjY). Since then\n// the JavaScript version has been used to build some really nice interfaces.\n// Check out [brandonwalkin.com](http://brandonwalkin.com) for an\n// example.\n//\n// Overview\n// --------\n// The Library provides a SpringSystem for maintaining a set of Spring\n// objects and iterating those Springs through a physics solver loop\n// until equilibrium is achieved. The Spring class is the basic\n// animation driver provided by Rebound. By attaching a listener to\n// a Spring, you can observe its motion. The observer function is\n// notified of position changes on the spring as it solves for\n// equilibrium. These position updates can be mapped to an animation\n// range to drive animated property updates on your user interface\n// elements (translation, rotation, scale, etc).\n//\n// Example\n// -------\n// Here's a simple example. Pressing and releasing on the logo below\n// will cause it to scale up and down with a springy animation.\n//\n// <div style=\"text-align:center; margin-bottom:50px; margin-top:50px\">\n//   <img\n//     src=\"http://facebook.github.io/rebound/images/rebound.png\"\n//     id=\"logo\"\n//   />\n// </div>\n// <script src=\"../rebound.min.js\"></script>\n// <script>\n//\n// function scale(el, val) {\n//   el.style.mozTransform =\n//   el.style.msTransform =\n//   el.style.webkitTransform =\n//   el.style.transform = 'scale3d(' + val + ', ' + val + ', 1)';\n// }\n// var el = document.getElementById('logo');\n//\n// var springSystem = new rebound.SpringSystem();\n// var spring = springSystem.createSpring(50, 3);\n// spring.addListener({\n//   onSpringUpdate: function(spring) {\n//     var val = spring.getCurrentValue();\n//     val = rebound.MathUtil.mapValueInRange(val, 0, 1, 1, 0.5);\n//     scale(el, val);\n//   }\n// });\n//\n// el.addEventListener('mousedown', function() {\n//   spring.setEndValue(1);\n// });\n//\n// el.addEventListener('mouseout', function() {\n//   spring.setEndValue(0);\n// });\n//\n// el.addEventListener('mouseup', function() {\n//   spring.setEndValue(0);\n// });\n//\n// </script>\n//\n// Here's how it works.\n//\n// ```\n// // Get a reference to the logo element.\n// var el = document.getElementById('logo');\n//\n// // create a SpringSystem and a Spring with a bouncy config.\n// var springSystem = new rebound.SpringSystem();\n// var spring = springSystem.createSpring(50, 3);\n//\n// // Add a listener to the spring. Every time the physics\n// // solver updates the Spring's value onSpringUpdate will\n// // be called.\n// spring.addListener({\n//   onSpringUpdate: function(spring) {\n//     var val = spring.getCurrentValue();\n//     val = rebound.MathUtil\n//                  .mapValueInRange(val, 0, 1, 1, 0.5);\n//     scale(el, val);\n//   }\n// });\n//\n// // Listen for mouse down/up/out and toggle the\n// //springs endValue from 0 to 1.\n// el.addEventListener('mousedown', function() {\n//   spring.setEndValue(1);\n// });\n//\n// el.addEventListener('mouseout', function() {\n//   spring.setEndValue(0);\n// });\n//\n// el.addEventListener('mouseup', function() {\n//   spring.setEndValue(0);\n// });\n//\n// // Helper for scaling an element with css transforms.\n// function scale(el, val) {\n//   el.style.mozTransform =\n//   el.style.msTransform =\n//   el.style.webkitTransform =\n//   el.style.transform = 'scale3d(' +\n//     val + ', ' + val + ', 1)';\n// }\n// ```\n\n(function() {\n  var rebound = {};\n  var util = rebound.util = {};\n  var concat = Array.prototype.concat;\n  var slice = Array.prototype.slice;\n\n  // Bind a function to a context object.\n  util.bind = function bind(func, context) {\n    var args = slice.call(arguments, 2);\n    return function() {\n      func.apply(context, concat.call(args, slice.call(arguments)));\n    };\n  };\n\n  // Add all the properties in the source to the target.\n  util.extend = function extend(target, source) {\n    for (var key in source) {\n      if (source.hasOwnProperty(key)) {\n        target[key] = source[key];\n      }\n    }\n  };\n\n  // SpringSystem\n  // ------------\n  // **SpringSystem** is a set of Springs that all run on the same physics\n  // timing loop. To get started with a Rebound animation you first\n  // create a new SpringSystem and then add springs to it.\n  var SpringSystem = rebound.SpringSystem = function SpringSystem(looper) {\n    this._springRegistry = {};\n    this._activeSprings = [];\n    this.listeners = [];\n    this._idleSpringIndices = [];\n    this.looper = looper || new AnimationLooper();\n    this.looper.springSystem = this;\n  };\n\n  util.extend(SpringSystem.prototype, {\n\n    _springRegistry: null,\n\n    _isIdle: true,\n\n    _lastTimeMillis: -1,\n\n    _activeSprings: null,\n\n    listeners: null,\n\n    _idleSpringIndices: null,\n\n    // A SpringSystem is iterated by a looper. The looper is responsible\n    // for executing each frame as the SpringSystem is resolved to idle.\n    // There are three types of Loopers described below AnimationLooper,\n    // SimulationLooper, and SteppingSimulationLooper. AnimationLooper is\n    // the default as it is the most useful for common UI animations.\n    setLooper: function(looper) {\n      this.looper = looper;\n      looper.springSystem = this;\n    },\n\n    // Add a new spring to this SpringSystem. This Spring will now be solved for\n    // during the physics iteration loop. By default the spring will use the\n    // default Origami spring config with 40 tension and 7 friction, but you can\n    // also provide your own values here.\n    createSpring: function(tension, friction) {\n      var springConfig;\n      if (tension === undefined || friction === undefined) {\n        springConfig = SpringConfig.DEFAULT_ORIGAMI_SPRING_CONFIG;\n      } else {\n        springConfig =\n          SpringConfig.fromOrigamiTensionAndFriction(tension, friction);\n      }\n      return this.createSpringWithConfig(springConfig);\n    },\n\n    // Add a spring with a specified bounciness and speed. To replicate Origami\n    // compositions based on PopAnimation patches, use this factory method to\n    // create matching springs.\n    createSpringWithBouncinessAndSpeed: function(bounciness, speed) {\n      var springConfig;\n      if (bounciness === undefined || speed === undefined) {\n        springConfig = SpringConfig.DEFAULT_ORIGAMI_SPRING_CONFIG;\n      } else {\n        springConfig =\n          SpringConfig.fromBouncinessAndSpeed(bounciness, speed);\n      }\n      return this.createSpringWithConfig(springConfig);\n    },\n\n    // Add a spring with the provided SpringConfig.\n    createSpringWithConfig: function(springConfig) {\n      var spring = new Spring(this);\n      this.registerSpring(spring);\n      spring.setSpringConfig(springConfig);\n      return spring;\n    },\n\n    // You can check if a SpringSystem is idle or active by calling\n    // getIsIdle. If all of the Springs in the SpringSystem are at rest,\n    // i.e. the physics forces have reached equilibrium, then this\n    // method will return true.\n    getIsIdle: function() {\n      return this._isIdle;\n    },\n\n    // Retrieve a specific Spring from the SpringSystem by id. This\n    // can be useful for inspecting the state of a spring before\n    // or after an integration loop in the SpringSystem executes.\n    getSpringById: function (id) {\n      return this._springRegistry[id];\n    },\n\n    // Get a listing of all the springs registered with this\n    // SpringSystem.\n    getAllSprings: function() {\n      var vals = [];\n      for (var id in this._springRegistry) {\n        if (this._springRegistry.hasOwnProperty(id)) {\n          vals.push(this._springRegistry[id]);\n        }\n      }\n      return vals;\n    },\n\n    // registerSpring is called automatically as soon as you create\n    // a Spring with SpringSystem#createSpring. This method sets the\n    // spring up in the registry so that it can be solved in the\n    // solver loop.\n    registerSpring: function(spring) {\n      this._springRegistry[spring.getId()] = spring;\n    },\n\n    // Deregister a spring with this SpringSystem. The SpringSystem will\n    // no longer consider this Spring during its integration loop once\n    // this is called. This is normally done automatically for you when\n    // you call Spring#destroy.\n    deregisterSpring: function(spring) {\n      removeFirst(this._activeSprings, spring);\n      delete this._springRegistry[spring.getId()];\n    },\n\n    advance: function(time, deltaTime) {\n      while(this._idleSpringIndices.length > 0) this._idleSpringIndices.pop();\n      for (var i = 0, len = this._activeSprings.length; i < len; i++) {\n        var spring = this._activeSprings[i];\n        if (spring.systemShouldAdvance()) {\n          spring.advance(time / 1000.0, deltaTime / 1000.0);\n        } else {\n          this._idleSpringIndices.push(this._activeSprings.indexOf(spring));\n        }\n      }\n      while(this._idleSpringIndices.length > 0) {\n        var idx = this._idleSpringIndices.pop();\n        idx >= 0 && this._activeSprings.splice(idx, 1);\n      }\n    },\n\n    // This is our main solver loop called to move the simulation\n    // forward through time. Before each pass in the solver loop\n    // onBeforeIntegrate is called on an any listeners that have\n    // registered themeselves with the SpringSystem. This gives you\n    // an opportunity to apply any constraints or adjustments to\n    // the springs that should be enforced before each iteration\n    // loop. Next the advance method is called to move each Spring in\n    // the systemShouldAdvance forward to the current time. After the\n    // integration step runs in advance, onAfterIntegrate is called\n    // on any listeners that have registered themselves with the\n    // SpringSystem. This gives you an opportunity to run any post\n    // integration constraints or adjustments on the Springs in the\n    // SpringSystem.\n    loop: function(currentTimeMillis) {\n      var listener;\n      if (this._lastTimeMillis === -1) {\n        this._lastTimeMillis = currentTimeMillis -1;\n      }\n      var ellapsedMillis = currentTimeMillis - this._lastTimeMillis;\n      this._lastTimeMillis = currentTimeMillis;\n\n      var i = 0, len = this.listeners.length;\n      for (i = 0; i < len; i++) {\n        listener = this.listeners[i];\n        listener.onBeforeIntegrate && listener.onBeforeIntegrate(this);\n      }\n\n      this.advance(currentTimeMillis, ellapsedMillis);\n      if (this._activeSprings.length === 0) {\n        this._isIdle = true;\n        this._lastTimeMillis = -1;\n      }\n\n      for (i = 0; i < len; i++) {\n        listener = this.listeners[i];\n        listener.onAfterIntegrate && listener.onAfterIntegrate(this);\n      }\n\n      if (!this._isIdle) {\n        this.looper.run();\n      }\n    },\n\n    // activateSpring is used to notify the SpringSystem that a Spring\n    // has become displaced. The system responds by starting its solver\n    // loop up if it is currently idle.\n    activateSpring: function(springId) {\n      var spring = this._springRegistry[springId];\n      if (this._activeSprings.indexOf(spring) == -1) {\n        this._activeSprings.push(spring);\n      }\n      if (this.getIsIdle()) {\n        this._isIdle = false;\n        this.looper.run();\n      }\n    },\n\n    // Add a listener to the SpringSystem so that you can receive\n    // before/after integration notifications allowing Springs to be\n    // constrained or adjusted.\n    addListener: function(listener) {\n      this.listeners.push(listener);\n    },\n\n    // Remove a previously added listener on the SpringSystem.\n    removeListener: function(listener) {\n      removeFirst(this.listeners, listener);\n    },\n\n    // Remove all previously added listeners on the SpringSystem.\n    removeAllListeners: function() {\n      this.listeners = [];\n    }\n\n  });\n\n  // Spring\n  // ------\n  // **Spring** provides a model of a classical spring acting to\n  // resolve a body to equilibrium. Springs have configurable\n  // tension which is a force multipler on the displacement of the\n  // spring from its rest point or `endValue` as defined by [Hooke's\n  // law](http://en.wikipedia.org/wiki/Hooke's_law). Springs also have\n  // configurable friction, which ensures that they do not oscillate\n  // infinitely. When a Spring is displaced by updating it's resting\n  // or `currentValue`, the SpringSystems that contain that Spring\n  // will automatically start looping to solve for equilibrium. As each\n  // timestep passes, `SpringListener` objects attached to the Spring\n  // will be notified of the updates providing a way to drive an\n  // animation off of the spring's resolution curve.\n  var Spring = rebound.Spring = function Spring(springSystem) {\n    this._id = 's' + Spring._ID++;\n    this._springSystem = springSystem;\n    this.listeners = [];\n    this._currentState = new PhysicsState();\n    this._previousState = new PhysicsState();\n    this._tempState = new PhysicsState();\n  };\n\n  util.extend(Spring, {\n    _ID: 0,\n\n    MAX_DELTA_TIME_SEC: 0.064,\n\n    SOLVER_TIMESTEP_SEC: 0.001\n\n  });\n\n  util.extend(Spring.prototype, {\n\n    _id: 0,\n\n    _springConfig: null,\n\n    _overshootClampingEnabled: false,\n\n    _currentState: null,\n\n    _previousState: null,\n\n    _tempState: null,\n\n    _startValue: 0,\n\n    _endValue: 0,\n\n    _wasAtRest: true,\n\n    _restSpeedThreshold: 0.001,\n\n    _displacementFromRestThreshold: 0.001,\n\n    listeners: null,\n\n    _timeAccumulator: 0,\n\n    _springSystem: null,\n\n    // Remove a Spring from simulation and clear its listeners.\n    destroy: function() {\n      this.listeners = [];\n      this.frames = [];\n      this._springSystem.deregisterSpring(this);\n    },\n\n    // Get the id of the spring, which can be used to retrieve it from\n    // the SpringSystems it participates in later.\n    getId: function() {\n      return this._id;\n    },\n\n    // Set the configuration values for this Spring. A SpringConfig\n    // contains the tension and friction values used to solve for the\n    // equilibrium of the Spring in the physics loop.\n    setSpringConfig: function(springConfig) {\n      this._springConfig = springConfig;\n      return this;\n    },\n\n    // Retrieve the SpringConfig used by this Spring.\n    getSpringConfig: function() {\n      return this._springConfig;\n    },\n\n    // Set the current position of this Spring. Listeners will be updated\n    // with this value immediately. If the rest or `endValue` is not\n    // updated to match this value, then the spring will be dispalced and\n    // the SpringSystem will start to loop to restore the spring to the\n    // `endValue`.\n    //\n    // A common pattern is to move a Spring around without animation by\n    // calling.\n    //\n    // ```\n    // spring.setCurrentValue(n).setAtRest();\n    // ```\n    //\n    // This moves the Spring to a new position `n`, sets the endValue\n    // to `n`, and removes any velocity from the `Spring`. By doing\n    // this you can allow the `SpringListener` to manage the position\n    // of UI elements attached to the spring even when moving without\n    // animation. For example, when dragging an element you can\n    // update the position of an attached view through a spring\n    // by calling `spring.setCurrentValue(x)`. When\n    // the gesture ends you can update the Springs\n    // velocity and endValue\n    // `spring.setVelocity(gestureEndVelocity).setEndValue(flingTarget)`\n    // to cause it to naturally animate the UI element to the resting\n    // position taking into account existing velocity. The codepaths for\n    // synchronous movement and spring driven animation can\n    // be unified using this technique.\n    setCurrentValue: function(currentValue, skipSetAtRest) {\n      this._startValue = currentValue;\n      this._currentState.position = currentValue;\n      if (!skipSetAtRest) {\n        this.setAtRest();\n      }\n      this.notifyPositionUpdated(false, false);\n      return this;\n    },\n\n    // Get the position that the most recent animation started at. This\n    // can be useful for determining the number off oscillations that\n    // have occurred.\n    getStartValue: function() {\n      return this._startValue;\n    },\n\n    // Retrieve the current value of the Spring.\n    getCurrentValue: function() {\n      return this._currentState.position;\n    },\n\n    // Get the absolute distance of the Spring from it's resting endValue\n    // position.\n    getCurrentDisplacementDistance: function() {\n      return this.getDisplacementDistanceForState(this._currentState);\n    },\n\n    getDisplacementDistanceForState: function(state) {\n      return Math.abs(this._endValue - state.position);\n    },\n\n    // Set the endValue or resting position of the spring. If this\n    // value is different than the current value, the SpringSystem will\n    // be notified and will begin running its solver loop to resolve\n    // the Spring to equilibrium. Any listeners that are registered\n    // for onSpringEndStateChange will also be notified of this update\n    // immediately.\n    setEndValue: function(endValue) {\n      if (this._endValue == endValue && this.isAtRest())  {\n        return this;\n      }\n      this._startValue = this.getCurrentValue();\n      this._endValue = endValue;\n      this._springSystem.activateSpring(this.getId());\n      for (var i = 0, len = this.listeners.length; i < len; i++) {\n        var listener = this.listeners[i];\n        var onChange = listener.onSpringEndStateChange;\n        onChange && onChange(this);\n      }\n      return this;\n    },\n\n    // Retrieve the endValue or resting position of this spring.\n    getEndValue: function() {\n      return this._endValue;\n    },\n\n    // Set the current velocity of the Spring. As previously mentioned,\n    // this can be useful when you are performing a direct manipulation\n    // gesture. When a UI element is released you may call setVelocity\n    // on its animation Spring so that the Spring continues with the\n    // same velocity as the gesture ended with. The friction, tension,\n    // and displacement of the Spring will then govern its motion to\n    // return to rest on a natural feeling curve.\n    setVelocity: function(velocity) {\n      if (velocity === this._currentState.velocity) {\n        return this;\n      }\n      this._currentState.velocity = velocity;\n      this._springSystem.activateSpring(this.getId());\n      return this;\n    },\n\n    // Get the current velocity of the Spring.\n    getVelocity: function() {\n      return this._currentState.velocity;\n    },\n\n    // Set a threshold value for the movement speed of the Spring below\n    // which it will be considered to be not moving or resting.\n    setRestSpeedThreshold: function(restSpeedThreshold) {\n      this._restSpeedThreshold = restSpeedThreshold;\n      return this;\n    },\n\n    // Retrieve the rest speed threshold for this Spring.\n    getRestSpeedThreshold: function() {\n      return this._restSpeedThreshold;\n    },\n\n    // Set a threshold value for displacement below which the Spring\n    // will be considered to be not displaced i.e. at its resting\n    // `endValue`.\n    setRestDisplacementThreshold: function(displacementFromRestThreshold) {\n      this._displacementFromRestThreshold = displacementFromRestThreshold;\n    },\n\n    // Retrieve the rest displacement threshold for this spring.\n    getRestDisplacementThreshold: function() {\n      return this._displacementFromRestThreshold;\n    },\n\n    // Enable overshoot clamping. This means that the Spring will stop\n    // immediately when it reaches its resting position regardless of\n    // any existing momentum it may have. This can be useful for certain\n    // types of animations that should not oscillate such as a scale\n    // down to 0 or alpha fade.\n    setOvershootClampingEnabled: function(enabled) {\n      this._overshootClampingEnabled = enabled;\n      return this;\n    },\n\n    // Check if overshoot clamping is enabled for this spring.\n    isOvershootClampingEnabled: function() {\n      return this._overshootClampingEnabled;\n    },\n\n    // Check if the Spring has gone past its end point by comparing\n    // the direction it was moving in when it started to the current\n    // position and end value.\n    isOvershooting: function() {\n      var start = this._startValue;\n      var end = this._endValue;\n      return this._springConfig.tension > 0 &&\n       ((start < end && this.getCurrentValue() > end) ||\n       (start > end && this.getCurrentValue() < end));\n    },\n\n    // Spring.advance is the main solver method for the Spring. It takes\n    // the current time and delta since the last time step and performs\n    // an RK4 integration to get the new position and velocity state\n    // for the Spring based on the tension, friction, velocity, and\n    // displacement of the Spring.\n    advance: function(time, realDeltaTime) {\n      var isAtRest = this.isAtRest();\n\n      if (isAtRest && this._wasAtRest) {\n        return;\n      }\n\n      var adjustedDeltaTime = realDeltaTime;\n      if (realDeltaTime > Spring.MAX_DELTA_TIME_SEC) {\n        adjustedDeltaTime = Spring.MAX_DELTA_TIME_SEC;\n      }\n\n      this._timeAccumulator += adjustedDeltaTime;\n\n      var tension = this._springConfig.tension,\n          friction = this._springConfig.friction,\n\n          position = this._currentState.position,\n          velocity = this._currentState.velocity,\n          tempPosition = this._tempState.position,\n          tempVelocity = this._tempState.velocity,\n\n          aVelocity, aAcceleration,\n          bVelocity, bAcceleration,\n          cVelocity, cAcceleration,\n          dVelocity, dAcceleration,\n\n          dxdt, dvdt;\n\n      while(this._timeAccumulator >= Spring.SOLVER_TIMESTEP_SEC) {\n\n        this._timeAccumulator -= Spring.SOLVER_TIMESTEP_SEC;\n\n        if (this._timeAccumulator < Spring.SOLVER_TIMESTEP_SEC) {\n          this._previousState.position = position;\n          this._previousState.velocity = velocity;\n        }\n\n        aVelocity = velocity;\n        aAcceleration =\n          (tension * (this._endValue - tempPosition)) - friction * velocity;\n\n        tempPosition = position + aVelocity * Spring.SOLVER_TIMESTEP_SEC * 0.5;\n        tempVelocity =\n          velocity + aAcceleration * Spring.SOLVER_TIMESTEP_SEC * 0.5;\n        bVelocity = tempVelocity;\n        bAcceleration =\n          (tension * (this._endValue - tempPosition)) - friction * tempVelocity;\n\n        tempPosition = position + bVelocity * Spring.SOLVER_TIMESTEP_SEC * 0.5;\n        tempVelocity =\n          velocity + bAcceleration * Spring.SOLVER_TIMESTEP_SEC * 0.5;\n        cVelocity = tempVelocity;\n        cAcceleration =\n          (tension * (this._endValue - tempPosition)) - friction * tempVelocity;\n\n        tempPosition = position + cVelocity * Spring.SOLVER_TIMESTEP_SEC * 0.5;\n        tempVelocity =\n          velocity + cAcceleration * Spring.SOLVER_TIMESTEP_SEC * 0.5;\n        dVelocity = tempVelocity;\n        dAcceleration =\n          (tension * (this._endValue - tempPosition)) - friction * tempVelocity;\n\n        dxdt =\n          1.0/6.0 * (aVelocity + 2.0 * (bVelocity + cVelocity) + dVelocity);\n        dvdt = 1.0/6.0 * (\n          aAcceleration + 2.0 * (bAcceleration + cAcceleration) + dAcceleration\n        );\n\n        position += dxdt * Spring.SOLVER_TIMESTEP_SEC;\n        velocity += dvdt * Spring.SOLVER_TIMESTEP_SEC;\n      }\n\n      this._tempState.position = tempPosition;\n      this._tempState.velocity = tempVelocity;\n\n      this._currentState.position = position;\n      this._currentState.velocity = velocity;\n\n      if (this._timeAccumulator > 0) {\n        this._interpolate(this._timeAccumulator / Spring.SOLVER_TIMESTEP_SEC);\n      }\n\n      if (this.isAtRest() ||\n          this._overshootClampingEnabled && this.isOvershooting()) {\n\n        if (this._springConfig.tension > 0) {\n          this._startValue = this._endValue;\n          this._currentState.position = this._endValue;\n        } else {\n          this._endValue = this._currentState.position;\n          this._startValue = this._endValue;\n        }\n        this.setVelocity(0);\n        isAtRest = true;\n      }\n\n      var notifyActivate = false;\n      if (this._wasAtRest) {\n        this._wasAtRest = false;\n        notifyActivate = true;\n      }\n\n      var notifyAtRest = false;\n      if (isAtRest) {\n        this._wasAtRest = true;\n        notifyAtRest = true;\n      }\n\n      this.notifyPositionUpdated(notifyActivate, notifyAtRest);\n    },\n\n    notifyPositionUpdated: function(notifyActivate, notifyAtRest) {\n      for (var i = 0, len = this.listeners.length; i < len; i++) {\n        var listener = this.listeners[i];\n        if (notifyActivate && listener.onSpringActivate) {\n          listener.onSpringActivate(this);\n        }\n\n        if (listener.onSpringUpdate) {\n          listener.onSpringUpdate(this);\n        }\n\n        if (notifyAtRest && listener.onSpringAtRest) {\n          listener.onSpringAtRest(this);\n        }\n      }\n    },\n\n\n    // Check if the SpringSystem should advance. Springs are advanced\n    // a final frame after they reach equilibrium to ensure that the\n    // currentValue is exactly the requested endValue regardless of the\n    // displacement threshold.\n    systemShouldAdvance: function() {\n      return !this.isAtRest() || !this.wasAtRest();\n    },\n\n    wasAtRest: function() {\n      return this._wasAtRest;\n    },\n\n    // Check if the Spring is atRest meaning that it's currentValue and\n    // endValue are the same and that it has no velocity. The previously\n    // described thresholds for speed and displacement define the bounds\n    // of this equivalence check. If the Spring has 0 tension, then it will\n    // be considered at rest whenever its absolute velocity drops below the\n    // restSpeedThreshold.\n    isAtRest: function() {\n      return Math.abs(this._currentState.velocity) < this._restSpeedThreshold &&\n        (this.getDisplacementDistanceForState(this._currentState) <=\n          this._displacementFromRestThreshold ||\n        this._springConfig.tension === 0);\n    },\n\n    // Force the spring to be at rest at its current position. As\n    // described in the documentation for setCurrentValue, this method\n    // makes it easy to do synchronous non-animated updates to ui\n    // elements that are attached to springs via SpringListeners.\n    setAtRest: function() {\n      this._endValue = this._currentState.position;\n      this._tempState.position = this._currentState.position;\n      this._currentState.velocity = 0;\n      return this;\n    },\n\n    _interpolate: function(alpha) {\n      this._currentState.position = this._currentState.position *\n        alpha + this._previousState.position * (1 - alpha);\n      this._currentState.velocity = this._currentState.velocity *\n        alpha + this._previousState.velocity * (1 - alpha);\n    },\n\n    getListeners: function() {\n      return this.listeners;\n    },\n\n    addListener: function(newListener) {\n      this.listeners.push(newListener);\n      return this;\n    },\n\n    removeListener: function(listenerToRemove) {\n      removeFirst(this.listeners, listenerToRemove);\n      return this;\n    },\n\n    removeAllListeners: function() {\n      this.listeners = [];\n      return this;\n    },\n\n    currentValueIsApproximately: function(value) {\n      return Math.abs(this.getCurrentValue() - value) <=\n        this.getRestDisplacementThreshold();\n    }\n\n  });\n\n  // PhysicsState\n  // ------------\n  // **PhysicsState** consists of a position and velocity. A Spring uses\n  // this internally to keep track of its current and prior position and\n  // velocity values.\n  var PhysicsState = function PhysicsState() {};\n\n  util.extend(PhysicsState.prototype, {\n    position: 0,\n    velocity: 0\n  });\n\n  // SpringConfig\n  // ------------\n  // **SpringConfig** maintains a set of tension and friction constants\n  // for a Spring. You can use fromOrigamiTensionAndFriction to convert\n  // values from the [Origami](http://facebook.github.io/origami/)\n  // design tool directly to Rebound spring constants.\n  var SpringConfig = rebound.SpringConfig =\n    function SpringConfig(tension, friction) {\n      this.tension = tension;\n      this.friction = friction;\n    };\n\n  // Loopers\n  // -------\n  // **AnimationLooper** plays each frame of the SpringSystem on animation\n  // timing loop. This is the default type of looper for a new spring system\n  // as it is the most common when developing UI.\n  var AnimationLooper = rebound.AnimationLooper = function AnimationLooper() {\n    this.springSystem = null;\n    var _this = this;\n    var _run = function() {\n      _this.springSystem.loop(Date.now());\n    };\n\n    this.run = function() {\n      util.onFrame(_run);\n    };\n  };\n\n  // **SimulationLooper** resolves the SpringSystem to a resting state in a\n  // tight and blocking loop. This is useful for synchronously generating\n  // pre-recorded animations that can then be played on a timing loop later.\n  // Sometimes this lead to better performance to pre-record a single spring\n  // curve and use it to drive many animations; however, it can make dynamic\n  // response to user input a bit trickier to implement.\n  rebound.SimulationLooper = function SimulationLooper(timestep) {\n    this.springSystem = null;\n    var time = 0;\n    var running = false;\n    timestep=timestep || 16.667;\n\n    this.run = function() {\n      if (running) {\n        return;\n      }\n      running = true;\n      while(!this.springSystem.getIsIdle()) {\n        this.springSystem.loop(time+=timestep);\n      }\n      running = false;\n    };\n  };\n\n  // **SteppingSimulationLooper** resolves the SpringSystem one step at a\n  // time controlled by an outside loop. This is useful for testing and\n  // verifying the behavior of a SpringSystem or if you want to control your own\n  // timing loop for some reason e.g. slowing down or speeding up the\n  // simulation.\n  rebound.SteppingSimulationLooper = function(timestep) {\n    this.springSystem = null;\n    var time = 0;\n\n    // this.run is NOOP'd here to allow control from the outside using\n    // this.step.\n    this.run = function(){};\n\n    // Perform one step toward resolving the SpringSystem.\n    this.step = function(timestep) {\n      this.springSystem.loop(time+=timestep);\n    };\n  };\n\n  // Math for converting from\n  // [Origami](http://facebook.github.io/origami/) to\n  // [Rebound](http://facebook.github.io/rebound).\n  // You mostly don't need to worry about this, just use\n  // SpringConfig.fromOrigamiTensionAndFriction(v, v);\n  var OrigamiValueConverter = rebound.OrigamiValueConverter = {\n    tensionFromOrigamiValue: function(oValue) {\n      return (oValue - 30.0) * 3.62 + 194.0;\n    },\n\n    origamiValueFromTension: function(tension) {\n      return (tension - 194.0) / 3.62 + 30.0;\n    },\n\n    frictionFromOrigamiValue: function(oValue) {\n      return (oValue - 8.0) * 3.0 + 25.0;\n    },\n\n    origamiFromFriction: function(friction) {\n      return (friction - 25.0) / 3.0 + 8.0;\n    }\n  };\n\n  // BouncyConversion provides math for converting from Origami PopAnimation\n  // config values to regular Origami tension and friction values. If you are\n  // trying to replicate prototypes made with PopAnimation patches in Origami,\n  // then you should create your springs with\n  // SpringSystem.createSpringWithBouncinessAndSpeed, which uses this Math\n  // internally to create a spring to match the provided PopAnimation\n  // configuration from Origami.\n  var BouncyConversion = rebound.BouncyConversion = function(bounciness, speed){\n    this.bounciness = bounciness;\n    this.speed = speed;\n    var b = this.normalize(bounciness / 1.7, 0, 20.0);\n    b = this.projectNormal(b, 0.0, 0.8);\n    var s = this.normalize(speed / 1.7, 0, 20.0);\n    this.bouncyTension = this.projectNormal(s, 0.5, 200)\n    this.bouncyFriction = this.quadraticOutInterpolation(\n      b,\n      this.b3Nobounce(this.bouncyTension),\n      0.01);\n  }\n\n  util.extend(BouncyConversion.prototype, {\n\n    normalize: function(value, startValue, endValue) {\n      return (value - startValue) / (endValue - startValue);\n    },\n\n    projectNormal: function(n, start, end) {\n      return start + (n * (end - start));\n    },\n\n    linearInterpolation: function(t, start, end) {\n      return t * end + (1.0 - t) * start;\n    },\n\n    quadraticOutInterpolation: function(t, start, end) {\n      return this.linearInterpolation(2*t - t*t, start, end);\n    },\n\n    b3Friction1: function(x) {\n      return (0.0007 * Math.pow(x, 3)) -\n        (0.031 * Math.pow(x, 2)) + 0.64 * x + 1.28;\n    },\n\n    b3Friction2: function(x) {\n      return (0.000044 * Math.pow(x, 3)) -\n        (0.006 * Math.pow(x, 2)) + 0.36 * x + 2.;\n    },\n\n    b3Friction3: function(x) {\n      return (0.00000045 * Math.pow(x, 3)) -\n        (0.000332 * Math.pow(x, 2)) + 0.1078 * x + 5.84;\n    },\n\n    b3Nobounce: function(tension) {\n      var friction = 0;\n      if (tension <= 18) {\n        friction = this.b3Friction1(tension);\n      } else if (tension > 18 && tension <= 44) {\n        friction = this.b3Friction2(tension);\n      } else {\n        friction = this.b3Friction3(tension);\n      }\n      return friction;\n    }\n  });\n\n  util.extend(SpringConfig, {\n    // Convert an origami Spring tension and friction to Rebound spring\n    // constants. If you are prototyping a design with Origami, this\n    // makes it easy to make your springs behave exactly the same in\n    // Rebound.\n    fromOrigamiTensionAndFriction: function(tension, friction) {\n      return new SpringConfig(\n        OrigamiValueConverter.tensionFromOrigamiValue(tension),\n        OrigamiValueConverter.frictionFromOrigamiValue(friction));\n    },\n\n    // Convert an origami PopAnimation Spring bounciness and speed to Rebound\n    // spring constants. If you are using PopAnimation patches in Origami, this\n    // utility will provide springs that match your prototype.\n    fromBouncinessAndSpeed: function(bounciness, speed) {\n      var bouncyConversion = new rebound.BouncyConversion(bounciness, speed);\n      return this.fromOrigamiTensionAndFriction(\n        bouncyConversion.bouncyTension,\n        bouncyConversion.bouncyFriction);\n    },\n\n    // Create a SpringConfig with no tension or a coasting spring with some\n    // amount of Friction so that it does not coast infininitely.\n    coastingConfigWithOrigamiFriction: function(friction) {\n      return new SpringConfig(\n        0,\n        OrigamiValueConverter.frictionFromOrigamiValue(friction)\n      );\n    }\n  });\n\n  SpringConfig.DEFAULT_ORIGAMI_SPRING_CONFIG =\n    SpringConfig.fromOrigamiTensionAndFriction(40, 7);\n\n  util.extend(SpringConfig.prototype, {friction: 0, tension: 0});\n\n  // Here are a couple of function to convert colors between hex codes and RGB\n  // component values. These are handy when performing color\n  // tweening animations.\n  var colorCache = {};\n  util.hexToRGB = function(color) {\n    if (colorCache[color]) {\n      return colorCache[color];\n    }\n    color = color.replace('#', '');\n    if (color.length === 3) {\n      color = color[0] + color[0] + color[1] + color[1] + color[2] + color[2];\n    }\n    var parts = color.match(/.{2}/g);\n\n    var ret = {\n      r: parseInt(parts[0], 16),\n      g: parseInt(parts[1], 16),\n      b: parseInt(parts[2], 16)\n    };\n\n    colorCache[color] = ret;\n    return ret;\n  };\n\n  util.rgbToHex = function(r, g, b) {\n    r = r.toString(16);\n    g = g.toString(16);\n    b = b.toString(16);\n    r = r.length < 2 ? '0' + r : r;\n    g = g.length < 2 ? '0' + g : g;\n    b = b.length < 2 ? '0' + b : b;\n    return '#' + r + g + b;\n  };\n\n  var MathUtil = rebound.MathUtil = {\n    // This helper function does a linear interpolation of a value from\n    // one range to another. This can be very useful for converting the\n    // motion of a Spring to a range of UI property values. For example a\n    // spring moving from position 0 to 1 could be interpolated to move a\n    // view from pixel 300 to 350 and scale it from 0.5 to 1. The current\n    // position of the `Spring` just needs to be run through this method\n    // taking its input range in the _from_ parameters with the property\n    // animation range in the _to_ parameters.\n    mapValueInRange: function(value, fromLow, fromHigh, toLow, toHigh) {\n      var fromRangeSize = fromHigh - fromLow;\n      var toRangeSize = toHigh - toLow;\n      var valueScale = (value - fromLow) / fromRangeSize;\n      return toLow + (valueScale * toRangeSize);\n    },\n\n    // Interpolate two hex colors in a 0 - 1 range or optionally provide a\n    // custom range with fromLow,fromHight. The output will be in hex by default\n    // unless asRGB is true in which case it will be returned as an rgb string.\n    interpolateColor:\n      function(val, startColor, endColor, fromLow, fromHigh, asRGB) {\n      fromLow = fromLow === undefined ? 0 : fromLow;\n      fromHigh = fromHigh === undefined ? 1 : fromHigh;\n      startColor = util.hexToRGB(startColor);\n      endColor = util.hexToRGB(endColor);\n      var r = Math.floor(\n        util.mapValueInRange(val, fromLow, fromHigh, startColor.r, endColor.r)\n      );\n      var g = Math.floor(\n        util.mapValueInRange(val, fromLow, fromHigh, startColor.g, endColor.g)\n      );\n      var b = Math.floor(\n        util.mapValueInRange(val, fromLow, fromHigh, startColor.b, endColor.b)\n      );\n      if (asRGB) {\n        return 'rgb(' + r + ',' + g + ',' + b + ')';\n      } else {\n        return util.rgbToHex(r, g, b);\n      }\n    },\n\n    degreesToRadians: function(deg) {\n      return (deg * Math.PI) / 180;\n    },\n\n    radiansToDegrees: function(rad) {\n      return (rad * 180) / Math.PI;\n    }\n\n  }\n\n  util.extend(util, MathUtil);\n\n\n  // Utilities\n  // ---------\n  // Here are a few useful JavaScript utilities.\n\n  // Lop off the first occurence of the reference in the Array.\n  function removeFirst(array, item) {\n    var idx = array.indexOf(item);\n    idx != -1 && array.splice(idx, 1);\n  }\n\n  var _onFrame;\n  if (typeof window !== 'undefined') {\n    _onFrame = window.requestAnimationFrame ||\n      window.webkitRequestAnimationFrame ||\n      window.mozRequestAnimationFrame ||\n      window.msRequestAnimationFrame ||\n      window.oRequestAnimationFrame ||\n      function(callback) {\n        window.setTimeout(callback, 1000 / 60);\n      };\n  }\n  if (!_onFrame && typeof process !== 'undefined' && process.title === 'node') {\n    _onFrame = setImmediate;\n  }\n\n  // Cross browser/node timer functions.\n  util.onFrame = function onFrame(func) {\n    return _onFrame(func);\n  };\n\n  // Export the public api using exports for common js or the window for\n  // normal browser inclusion.\n  if (typeof exports != 'undefined') {\n    util.extend(exports, rebound);\n  } else if (typeof window != 'undefined') {\n    window.rebound = rebound;\n  }\n})();\n\n\n// Legal Stuff\n// -----------\n/**\n *  Copyright (c) 2013, Facebook, Inc.\n *  All rights reserved.\n *\n *  This source code is licensed under the BSD-style license found in the\n *  LICENSE file in the root directory of this source tree. An additional grant\n *  of patent rights can be found in the PATENTS file in the same directory.\n */\n","'use strict';\n\n/**\n * Polygon.\n * Create a regular polygon and provide api to compute inscribed child.\n */\nclass Polygon {\n\n  constructor(radius = 100, sides = 3, depth = 0, colors) {\n\n    this._radius = radius;\n    this._sides = sides;\n    this._depth = depth;\n    this._colors = colors;\n\n    this._x = 0;\n    this._y = 0;\n\n    this.rotation = 0;\n    this.scale = 1;\n\n    // Get basePolygon points straight away.\n    this.points = this._getRegularPolygonPoints();\n  }\n\n  /**\n   * Get the points of any regular polygon based on\n   * the number of sides and radius.\n   */\n  _getRegularPolygonPoints() {\n\n    let points = [];\n\n    let i = 0;\n\n    while (i < this._sides) {\n      // Note that sin and cos are inverted in order to draw\n      // polygon pointing down like: ∇\n      let x = -this._radius * Math.sin(i * 2 * Math.PI / this._sides);\n      let y = this._radius * Math.cos(i * 2 * Math.PI / this._sides);\n\n      points.push({x, y});\n\n      i++;\n    }\n\n    return points;\n  }\n\n  /**\n   * Get the inscribed polygon points by calling `getInterpolatedPoint`\n   * for the points (start, end) of each side.\n   */\n  _getInscribedPoints(points, progress) {\n\n    let inscribedPoints = [];\n\n    points.forEach((item, i) => {\n\n      let start = item;\n      let end = points[i + 1];\n\n      if (!end) {\n        end = points[0];\n      }\n\n      let point = this._getInterpolatedPoint(start, end, progress);\n\n      inscribedPoints.push(point);\n    });\n\n    return inscribedPoints;\n  }\n\n  /**\n   * Get interpolated point using linear interpolation\n   * on x and y axis.\n   */\n  _getInterpolatedPoint(start, end, progress) {\n\n    let Ax = start.x;\n    let Ay = start.y;\n\n    let Bx = end.x;\n    let By = end.y;\n\n    // Linear interpolation formula:\n    // point = start + (end - start) * progress;\n    let Cx = Ax + (Bx - Ax) * progress;\n    let Cy = Ay + (By - Ay) * progress;\n\n    return {\n      x: Cx,\n      y: Cy\n    };\n  }\n\n  /**\n   * Update children points array.\n   */\n  _getUpdatedChildren(progress) {\n\n    let children = [];\n\n    for (let i = 0; i < this._depth; i++) {\n\n      // Get basePolygon points on first lap\n      // then get previous child points.\n      let points = children[i - 1] || this.points;\n\n      let inscribedPoints = this._getInscribedPoints(points, progress);\n\n      children.push(inscribedPoints);\n    }\n\n    return children;\n  }\n\n  /**\n   * Render children, first update children array,\n   * then loop and draw each child.\n   */\n  renderChildren(context, progress) {\n\n    let children = this._getUpdatedChildren(progress);\n\n    // child = array of points at a certain progress over the parent sides.\n    children.forEach((points, i) => {\n\n      // Draw child.\n      context.beginPath();\n      points.forEach((point) => context.lineTo(point.x, point.y));\n      context.closePath();\n\n\n      // Set colors.\n      let strokeColor = this._colors.stroke;\n      let childColor = this._colors.child;\n\n      if (strokeColor) {\n        context.strokeStyle = strokeColor;\n        context.stroke();\n      }\n\n      if (childColor) {\n        let rgb = rebound.util.hexToRGB(childColor);\n\n        let alphaUnit = 1 / children.length;\n        let alpha = alphaUnit + (alphaUnit * i);\n\n        let rgba = `rgba(${rgb.r}, ${rgb.g}, ${rgb.b}, ${alpha})`;\n\n        context.fillStyle = rgba;\n\n        // Set Shadow.\n        context.shadowColor = 'rgba(0,0,0, 0.1)';\n        context.shadowBlur = 10;\n        context.shadowOffsetX = 0;\n        context.shadowOffsetY = 0;\n\n        context.fill();\n      }\n    });\n  }\n\n  /**\n   * Render.\n   */\n  render(context) {\n\n    context.save();\n\n    context.translate(this._x, this._y);\n\n    if (this.rotation !== 0) {\n      context.rotate(rebound.MathUtil.degreesToRadians(this.rotation));\n    }\n\n    if (this.scale !== 1) {\n      context.scale(this.scale, this.scale);\n    }\n\n    // Draw basePolygon.\n    context.beginPath();\n    this.points.forEach((point) => context.lineTo(point.x, point.y));\n    context.closePath();\n\n    // Set colors.\n    let strokeColor = this._colors.stroke;\n    let childColor = this._colors.base;\n\n    if (strokeColor) {\n      context.strokeStyle = strokeColor;\n      context.stroke();\n    }\n\n    if (childColor) {\n      context.fillStyle = childColor;\n      context.fill();\n    }\n\n    context.restore();\n  }\n}\n","'use strict';\n\n/**\n * Spinner.\n * Create a canvas element, append it to the body, render polygon with\n * inscribed children, provide init and complete methods to control spinner.\n */\nclass Spinner {\n\n  constructor(params) {\n\n    let id = params.id,\n        radius = params.radius,\n        sides = params.sides,\n        depth = params.depth,\n        colors = params.colors,\n        alwaysForward = params.alwaysForward,\n        restAt = params.restAt,\n        renderBase = params.renderBase;\n\n    if (sides < 3) {\n      console.warn('At least 3 sides required.');\n      sides = 3;\n    }\n\n    this._canvas = document.createElement('canvas');\n    this._canvas.style.backgroundColor = colors.background;\n\n    this._canvasW = null;\n    this._canvasH = null;\n    this._canvasOpacity = 1;\n\n    this._centerX = null;\n    this._centerY = null;\n\n    this._alwaysForward = alwaysForward;\n    this._restThreshold = restAt;\n    this._renderBase = renderBase;\n\n    this._springRangeLow = 0;\n    this._springRangeHigh = this._restThreshold || 1;\n\n    // Instantiate basePolygon.\n    this._basePolygon = new Polygon(radius, sides, depth, colors);\n\n    this._progress = 0;\n\n    this._isAutoSpin = null;\n    this._isCompleting = null;\n  }\n\n  /**\n   * Init spinner.\n   */\n  init(spring, autoSpin) {\n\n    this._addCanvas();\n\n    this._spring = spring;\n    this._addSpringListener();\n\n    this._isAutoSpin = autoSpin;\n\n    if (autoSpin) {\n      // Start auto spin.\n      this._spin();\n    } else {\n      // Render first frame only.\n      this._spring.setEndValue(0);\n      this.render();\n    }\n  }\n\n  _addCanvas() {\n    document.body.appendChild(this._canvas);\n    this._context = this._canvas.getContext('2d');\n    this._setCanvasSize();\n  }\n\n  _setCanvasSize() {\n    this._canvasW = this._canvas.width = window.innerWidth;\n    this._canvasH = this._canvas.height = window.innerHeight;\n\n    this._canvas.style.position = 'fixed';\n    this._canvas.style.top = 0;\n    this._canvas.style.left = 0;\n\n    this._centerX = this._canvasW / 2;\n    this._centerY = this._canvasH / 2;\n  }\n\n  _addSpringListener() {\n\n    let ctx = this;\n\n    // Add a listener to the spring. Every time the physics\n    // solver updates the Spring's value onSpringUpdate will\n    // be called.\n    this._spring.addListener({\n      onSpringUpdate(spring) {\n\n        let val = spring.getCurrentValue();\n\n            // Input range in the `from` parameters.\n        let fromLow = 0,\n            fromHigh = 1,\n            // Property animation range in the `to` parameters.\n            toLow = ctx._springRangeLow,\n            toHigh = ctx._springRangeHigh;\n\n        val = rebound.MathUtil.mapValueInRange(val, fromLow, fromHigh, toLow, toHigh);\n\n        // Note that the render method is\n        // called with the spring motion value.\n        ctx.render(val);\n      }\n    });\n  }\n\n  /**\n   * Start complete animation.\n   */\n  setComplete() {\n    this._isCompleting = true;\n  }\n\n  _completeAnimation() {\n\n    // Fade out the canvas.\n    this._canvasOpacity -= 0.1;\n    this._canvas.style.opacity = this._canvasOpacity;\n\n    // Stop animation and remove canvas.\n    if (this._canvasOpacity <= 0) {\n      this._isAutoSpin = false;\n      this._spring.setAtRest();\n      this._canvas.remove();\n    }\n  }\n\n  /**\n   * Spin animation.\n   */\n  _spin() {\n\n    if (this._alwaysForward) {\n\n      let currentValue = this._spring.getCurrentValue();\n\n      // Switch the animation range used to compute the value\n      // in the `onSpringUpdate`, so to change the reverse animation\n      // of the spring at a certain threshold.\n      if (this._restThreshold && currentValue === 1) {\n        this._switchSpringRange();\n      }\n\n      // In order to keep the motion going forward\n      // when spring reach 1 reset to 0 at rest.\n      if (currentValue === 1) {\n        this._spring.setCurrentValue(0).setAtRest();\n      }\n    }\n\n    // Restart the spinner.\n    this._spring.setEndValue((this._spring.getCurrentValue() === 1) ? 0 : 1);\n  }\n\n  _switchSpringRange() {\n\n    let threshold = this._restThreshold;\n\n    this._springRangeLow = (this._springRangeLow === threshold) ? 0 : threshold;\n    this._springRangeHigh = (this._springRangeHigh === threshold) ? 1 : threshold;\n  }\n\n  /**\n   * Render.\n   */\n  render(progress) {\n\n    // Update progess if present and round to 4th decimal.\n    if (progress) {\n      this._progress = Math.round(progress * 10000) / 10000;\n    }\n\n    // Restart the spin.\n    if (this._isAutoSpin && this._spring.isAtRest()) {\n      this._spin();\n    }\n\n    // Complete the animation.\n    if (this._isCompleting) {\n      this._completeAnimation();\n    }\n\n    // Clear canvas and save context.\n    this._context.clearRect(0, 0, this._canvasW, this._canvasH);\n    this._context.save();\n\n    // Move to center.\n    this._context.translate(this._centerX, this._centerY);\n\n    this._context.lineWidth = 1.5;\n\n    // Render basePolygon.\n    if (this._renderBase) {\n      this._basePolygon.render(this._context);\n    }\n\n    // Render inscribed polygons.\n    this._basePolygon.renderChildren(this._context, this._progress);\n\n    this._context.restore();\n  }\n}\n","'use strict';\n\n// Custom SETTINGS for each demo in related index.html\nlet settings = SETTINGS || {\n  rebound: {\n    tension: 2,\n    friction: 5\n  },\n  spinner: {\n    radius: 80,\n    sides: 3,\n    depth: 4,\n    colors: {\n      background: '#000000',\n      stroke: '#000000',\n      base: '#222222',\n      child: '#FFFFFF'\n    },\n    alwaysForward: true, // When false the spring will reverse normally.\n    restAt: 0.5, // A number from 0.1 to 0.9 || null for full rotation\n    renderBase: true // Optionally render basePolygon\n  }\n};\n\n/**\n * Demo.\n */\nconst demo = {\n  settings: settings,\n\n  spring: null,\n  spinner: null,\n\n  /**\n   * Initialize Rebound.js with settings.\n   * Rebound is used to generate a spring which\n   * is then used to animate the spinner.\n   * See more: http://facebook.github.io/rebound-js/docs/rebound.html\n   */\n  initRebound() {\n\n    let settings = demo.settings.rebound;\n\n    // Create a SpringSystem.\n    let springSystem = new rebound.SpringSystem();\n\n    // Add a spring to the system.\n    demo.spring = springSystem.createSpring(settings.tension, settings.friction);\n  },\n\n  /**\n   * Initialize Spinner with settings.\n   */\n  initSpinner() {\n\n    let settings = demo.settings.spinner;\n\n    // Instantiate Spinner.\n    demo.spinner = new Spinner(settings);\n  },\n\n  /**\n   * Initialize demo.\n   */\n  init() {\n\n    let spinnerTypeAutoSpin = true;\n\n    // Instantiate animation engine and spinner system.\n    demo.initRebound();\n    demo.initSpinner();\n\n    // Init animation with Rebound Spring System.\n    demo.spinner.init(demo.spring, spinnerTypeAutoSpin);\n\n    if (spinnerTypeAutoSpin) {\n      // Fake loading time, in a real world just call demo.spinner.setComplete();\n      // whenever the preload will be completed.\n      setTimeout(() => {\n        demo.spinner.setComplete();\n      }, 6000);\n    } else {\n      // Perform real ajax request.\n      demo.loadSomething();\n    }\n  },\n\n  /**\n   * Ajax Request.\n   */\n  loadSomething() {\n\n    let oReq = new XMLHttpRequest();\n\n    oReq.addEventListener('progress', (oEvent) => {\n      if (oEvent.lengthComputable) {\n\n        let percent = Math.ceil(oEvent.loaded / oEvent.total * 100);\n        console.log('ajax loding percent', percent);\n\n        // By setting the end value with the actual loading percentage\n        // the spinner will progress based on the actual ajax loading time.\n        demo.spring.setEndValue(percent * 0.01);\n      }\n    });\n\n    oReq.addEventListener('load', (e) => {\n      // Complete the loading animation.\n      demo.spinner.setComplete();\n    });\n\n    oReq.open('GET', '/img/something.jpg');\n    oReq.send();\n  }\n};\n"],"sourceRoot":"/source/"}