80 changed files with 25876 additions and 58849 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -1,18 +1,11 @@
 language: node_js
 node_js:
-  - '10'
+  - "0.10"
 before_install:
  - if [ "$CXX" = "g++" ]; then export CXX="g++-4.9" CC="gcc-4.9"; fi
 addons:
  apt:
    sources:
      - ubuntu-toolchain-r-test
    packages:
-      - pkg-config
+    - pkg-config
-      - libcairo2-dev
+    - libcairo2-dev
-      - libpango1.0-dev
+    - libjpeg8-dev
-      - libjpeg8-dev
+    - libgif-dev
      - libgif-dev
      - gcc-4.9
      - g++-4.9
 sudo: false
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -1,11 +0,0 @@
 Contributing
 ---
 The issue tracker is at [github.com/CartoDB/torque](https://github.com/CartoDB/torque).
 We love pull requests from everyone, see [Contributing to Open Source on GitHub](https://guides.github.com/activities/contributing-to-open-source/#contributing).
 ## Submitting Contributions
 * You will need to sign a Contributor License Agreement (CLA) before making a submission. [Learn more here](https://carto.com/contributions).
--- a/1
+++ b/1
@ -5,7 +5,6 @@ BROWSERIFY=./node_modules/browserify/bin/cmd.js
 JS_CLIENT_FILES= lib/torque/*.js \
 	lib/torque/renderer/*.js \
 	lib/torque/gmaps/*.js \
 	lib/torque/ol/*.js \
 	lib/torque/leaflet/leaflet_tileloader_mixin.js \
 	lib/torque/leaflet/canvas_layer.js \
 	lib/torque/leaflet/torque.js
--- a/45
+++ b/45
@ -1,48 +1,5 @@
 3.1.2 (2019-mm-dd)
 3.1.1 (2019-06-24)
    - Fixed reading undefined layer #306
 3.1.0 (2019-04-02)
    - Upgrade canvas to version 2.4.1
 3.0.0 (2019-03-29)
    - Drop support for Node.js 6 and 8
    - Handle exception: Image given has not completed loading
 2.17.1 (2019-01-23)
    - Upgrade deps:
        - turbo-carto@0.21.1
    - Upgrade devel deps:
        - browserify@16.2.3
        - qunitz@0.7.7
        - request@2.88.0
        - uglify-js@3.4.9
 2.17.0 (2018-11-21)
    - Use our current fork of mapnik while testing
    - Add support for Node 8 & 10
    - Support package-lock.json file
 v2.16.5
    -
 v2.16.4
    -
 2.16.2
    - Re-publish version
 2.16.1
    - Remove width trick to use clear rect #280
    - Map option reference broken gmaps #279
 2.16.0
    - Updated Turbo-carto dependency to version 0.19.0.
 2.15.1
-    - Fixed ready event then rendering more than one step
+    -
 2.15.0
    - Allow to render several steps at the same time (#247)
--- a/README.md
+++ b/README.md
@ -23,14 +23,14 @@ The library uses CartoDB to generate a [layercube](https://github.com/CartoDB/ti
 The simplest way to use a visualization with Torque is...
-#### Create a simple Torque visualization
+<div class="margin20"></div>
-
+<div class="code_title">Create a simple Torque visualization</div>
-```javascript
+  ``` javascript
-  ...
+      ...
-  <body>
+        <body>
-    <div id="map"></div>
+          <div id="map"></div>
-    ...
+        </body>
-    <script>
+      ...
      // define the torque layer style using cartocss
      var CARTOCSS = [
          'Map {',
@ -74,13 +74,17 @@ The simplest way to use a visualization with Torque is...
      });
      torqueLayer.addTo(map);
      torqueLayer.play()
    </script>
  </body>
 ```
    <script>
  ```
 [Grab the complete example source code](https://github.com/CartoDB/torque/blob/master/examples/navy_leaflet.html)
 <div class="margin20"></div>
 ### API
 [see reference](https://github.com/CartoDB/torque/blob/master/doc/API.md)
 ## Submitting Contributions
 * You will need to sign a Contributor License Agreement (CLA) before making a submission. [Learn more here.](https://cartodb.com/contributing)
--- a/dist/torque.full.js
+++ b/dist/torque.full.js
--- a/dist/torque.full.uncompressed.js
+++ b/dist/torque.full.uncompressed.js
--- a/dist/torque.js
+++ b/dist/torque.js
--- a/dist/torque.uncompressed.js
+++ b/dist/torque.uncompressed.js
--- a/doc/API.md
+++ b/doc/API.md
@ -0,0 +1,8 @@
 # Torque API
 Torque.js is an efficient and stylish rendering method to animate your data. Torque.js uses [TileCubes](http://wiki.osgeo.org/wiki/Tile_Map_Service_Specification), which are JSON representations of multidimensional data with geospatial coordinates, to render data on the client.
 ## Documentation
 * [Getting Started with Torque.js](getting_started.md)
 * [Torque API Methods](torque_api.md)
--- a/docs/guides/02-cartocss.md
+++ b/docs/guides/02-cartocss.md
@ -1,24 +1,23 @@
 ## Torque CartoCSS
-CartoCSS is one the tools of the CARTO platform. You can learn more about the different [components of CARTO platform]({{site.fundamental_docs}}/components/), or directly dig into [CartoCSS too]({{site.styling_cartocss}}/) details.
+# Torque CartoCSS
-`-torque-clear-color`
+## -torque-clear-color
 Color used to clear canvas on each frame.
-`-torque-frame-count`
+## -torque-frame-count
 Number of animation steps/frames used in the animation. If the data contains a fewer number of total frames, the lesser value will be used.
-`-torque-resolution`
+## -torque-resolution
 Spatial resolution in pixels. A resolution of 1 means no spatial aggregation of the data. Any other resolution of N results in spatial aggregation into cells of NxN pixels. The value N must be power of 2.
-`-torque-animation-duration`
+## -torque-animation-duration
 Animation duration in seconds.
-`-torque-aggregation-function`
+## -torque-aggregation-function
 A function used to calculate a value from the aggregate data for each cell. See [-torque-resolution](#-torque-resolution).
-`-torque-time-attribute`
+## -torque-time-attribute
 The table column that contains the time information used create the animation.
-`-torque-data-aggregation`
+## -torque-data-aggregation
 A linear animation will discard previous values while a cumulative animation will accumulate them until it restarts.
--- a/doc/getting_started.md
+++ b/doc/getting_started.md
@ -0,0 +1,93 @@
 # Getting Started
 Although the most straightforward way to use Torque is through either the CartoDB Editor, or by passing the layer's viz.json to [CartoDB.js](http://docs.cartodb.com/cartodb-platform/cartodb-js/getting-started/), many use cases work best with the standalone [Torque.js](https://github.com/CartoDB/torque/tree/master/dist). Assuming you have a public dataset with a `date` column, it is really simple to create an animated map with the library. First, you need to have a Leaflet map prepared in an HTML page:
 ```html
  <link rel="stylesheet" href="http://cdn.leafletjs.com/leaflet/v0.7.7/leaflet.css" />
  <body>
    <div id="map"></div>
    <script src="http://cdn.leafletjs.com/leaflet/v0.7.7/leaflet.js"></script>
    <script>
      var map = new L.Map('map', {
        zoomControl: true,
        center: [40, 0],
        zoom: 3
      });
      L.tileLayer('http://{s}.api.cartocdn.com/base-dark/{z}/{x}/{y}.png', {
        attribution: 'CartoDB'
      }).addTo(map);
    </script>
  </body>
 ```
 For Torque to work with your table, you only need a username, the name of the table, and a CartoCSS string to style the map. Leaflet's method `addTo` adds the Torque layer to the map. `play` runs the animation with the options specified in the CartoCSS properties.
 ```html
  <script>
    var CARTOCSS = [
      'Map {',
      '-torque-time-attribute: "date";',
      '-torque-aggregation-function: "count(cartodb_id)";',
      '-torque-frame-count: 760;',
      '-torque-animation-duration: 15;',
      '-torque-resolution: 2',
      '}',
      '#layer {',
      '  marker-width: 3;',
      '  marker-fill-opacity: 0.8;',
      '  marker-fill: #FEE391; ',
      '  comp-op: "lighten";',
      '}'
    ].join('\n');
    var torqueLayer = new L.TorqueLayer({
      user       : 'your_username',
      table      : 'your_table_name',
      cartocss: CARTOCSS
    });
    torqueLayer.addTo(map);
    torqueLayer.play()
  </script>
 ```
 You can use any kind of tile source outside CartoDB, by specifying the location of a [valid TileJSON](https://github.com/mapbox/tilejson-spec) file:
 ```javascript
  var torqueLayer = new L.TorqueLayer({
    tileJSON: 'http://url.to/tile.json'
    cartocss: CARTOCSS
  });
 ```
 Optionally, it is also possible to use a custom SQL query for your visualization:
 ```javascript
  var torqueLayer = new L.TorqueLayer({
    user       : 'your_username',
    table      : 'your_table_name',
    sql_query  : 'SELECT * FROM your_table_name WHERE whatever'
    cartocss: CARTOCSS
  });
 ```
 Like in a video player, you can use animation control methods such as `play`, `stop` and `pause` at any point. Torque's animator fires a `change:time` event each time the animation "ticks" to the next frame, and there are a number of properties and methods that can be run during playback, which are detailed in the [API documentation](/cartodb-platform/torque/torqueapi/). At any point, for example, the styling of the layer's markers can be changed using the `layer.setCartoCSS('##style##')`.
 ## Usage Examples
 The best way to start learning about the library is by taking a look at some of the examples below:
 * A basic example using the WWI British Navy dataset - ([view live](http://cartodb.github.io/torque/examples/navy_leaflet.html) / [source code](https://github.com/CartoDB/torque/blob/master/examples/navy_leaflet.html))
 * Using tileJSON to fetch tiles - ([view live](http://cartodb.github.io/torque/examples/tilejson.html) / [source code](https://github.com/CartoDB/torque/blob/master/examples/tilejson.html))
 * A car's route at the Nürburgring track mapped in Torque - ([view live](http://cartodb.github.io/torque/examples/car.html) / [source code](https://github.com/CartoDB/torque/blob/master/examples/car.html))
 ## Additional Torque Resources
 The following links contain examples, and other public information, about using Torque maps.
 - Torque [CartoCSS Reference page](https://github.com/cartodb/torque-reference), useful for building parsers, tests, compilers, and syntax highlighting/checking
 - CartoDB repository of [examples](https://github.com/CartoDB/torque/tree/master/examples)
 - A CartoDB [time example](http://cartodb.github.com/torque/) of a Torque map and data
 - CartoDB wiki page describing [how spatial aggregration works](https://github.com/CartoDB/torque/wiki/How-spatial-aggregation-works)
 - The [Guardian's Data Blog](http://www.guardian.co.uk/news/datablog/interactive/2012/oct/01/first-world-war-royal-navy-ships-mapped) about Royal Navy ships in WWI using a Torque map
 - An example of how to create a [simple Torque visualization](https://github.com/CartoDB/torque#getting-started) and the [source code](https://github.com/CartoDB/torque/blob/master/examples/navy_leaflet.html) used to create the example
 - An example of how to use CartoDB.js to [add a Torque layer from a named map with auth_tokens enabled](https://gist.github.com/chriswhong/a4d1e6305ecaf2ad507a)
--- a/doc/torque_api.md
+++ b/doc/torque_api.md
@ -0,0 +1,167 @@
 # Torque API
 ### L.TorqueLayer(options)
 A layer to be added to a Leaflet map. It works as a regular tiled layer within the Leaflet tile pane, but instead of containing `<img>` elements, it's composed of a single [`<canvas>`](https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API) where all markers are drawn.
 ```javascript
 var torqueLayer = new L.TorqueLayer({
  user: 'viz2',
  table: 'ow',
  cartocss: '<cartocss here>'
 });
 map.addLayer(torqueLayer);
 ```
 #### Options
 Name | Description
 --- | ---
 cartocss | A string object, the CartoCSS style for the map. Default value is  ```null```
 loop | A boolean object that defines the animation loop. Default value is ```true```. If ```false```, the animation is paused when it reaches the last frame
 resolution | Spatial resolution in pixels. A resolution of 1 means no spatial aggregation of the data. Its value must be a power of 2
 steps | Number of steps that the animation is divided into
 animationDuration | Duration, in seconds, of the animation
 zIndex | Z-Index CSS property of the layer
 attribution | Attribution to be added in the bottom right of the map
 maxZoom | Maximum zoom for the layer. 
 tileSize | Size, in pixels of the tiles
 ##### Using a CartoDB table directly
 Name | Description
 --- | ---
 user | A string object, your CartoDB [account name](/cartodb-editor/your-account/#account). Default value is  ```null```
 table | A string object, the CartoDB table name where data is found (also known as a dataset.) Default value is  ```null```
 ##### Using a custom SQL query
 Name | Description
 --- | ---
 query | A string object, the SQL query to be performed to fetch the data. Default value is ```null```.<br/><br/>You must use this param or table, but not at the same time
 **Tip:** For a Torque category layer that is created dynamically with `cartodb.createLayer`, the SQL query must explicitly include how to build the torque_category column. You must include both the `sql` and `table_name` parameters. See this [createLayer with torque category layer](https://gist.github.com/danicarrion/dcaf6f00a71aa55134b4) example.
 ##### Providing a TileJSON file
 Name | Description
 --- | ---
 tileJSON | A URL pointing to a valid [TileJSON](https://github.com/mapbox/tilejson-spec) file from which to get the Torque tile templates
 #### Time Methods
 Method | Options | Returns | Description |
 ---|---|---|---|
 `setStep(step)` | `time numeric` | `this` | the value must be between 0 and the total number of `steps` in the animation
 `play()` | | `this` | starts the animation
 `stop()` | | `this` | stops the animation and set time to step 0
 `pause()` | | `this` | stops the animation but keep the current time (play enables the animation again)
 `toggle()` | | `this` | toggles (pause/play) the animation
 `getStep()` | | current animation step (integer) | gets the current animation step. A step is considered an animation frame
 `getTime()` | | current animation time (Date) | gets the real animation time
 `isRunning()` | | `true`/`false` | describes whether the Torque layer is playing or is stopped
 **Note:** Torque.js interprets the beginning and ending date/time from your "Time Column" as one block, then divides that up into [Steps](/cartodb-platform/cartocss/properties-for-torque/#torque-frame-count-number), depending on the number you set. It does not necessarily draw one frame for each row. 
 #### Layer Control Methods
 Method | Options | Returns | Description
 ---|---|---|---
 `hide()` | none | `this` | hides the Torque layer
 `show()` | none| `this` | shows the Torque layer
 #### Style Methods 
 Method | Options | Returns | Description
 ---|---|---|---|
 `setCartoCSS(cartocss)` | `cartocss string` | `this` | style the map rendering using client-side CartoCSS (not available with [Named maps](/cartodb-platform/maps-api/named-maps/))
 Torque supports a limited subset of CartoCSS rules defined in the [torque-reference](https://github.com/cartodb/torque-reference). To see the full list of supported rules, read the [Torque CartoCSS documentation](/cartodb-platform/cartocss/properties-for-torque/). `value` and `zoom` variables can be used. `value` is the value of aggregation. `zoom` is the current zoom being rendered.
 TorqueLayer currently expects `marker` styling.
 #### Example
 This is how a minimal example of a stylesheet for a Torque visualisation would look like.
 ```css
 Map {
  -torque-time-attribute: "date";
  -torque-aggregation-function: "count(cartodb_id)";
  -torque-frame-count: 760;
  -torque-animation-duration: 15;
  -torque-resolution: 2;
 }
 #layer {
  marker-width: 3;
  marker-fill-opacity: 0.8;
  marker-fill: #FEE391; 
 }
 #layer[value = 4] { // Use of the value variable, generated by the function specified in -torque-aggregation-function
  marker-fill: #FABADA; 
 }
 #layer[zoom = 12] { // Use of the zoom variable
  marker-width: 10;
 }
 ```
 ### Data Methods
 Method | Options | Returns | Description
 ---|---|---|---
 `setSQL(sql statement)` | `SQL string` | `this` | Change the SQL on the data table (not available with named maps)
 `error(callback)` | `callback function with a list of errors as argument` | `this` | specifies a callback function to run if there are query errors
 #### Example
 SQL Example to limit the data used in the Torque map.
 ```js
 torqueLayer.setSQL("SELECT * FROM table LIMIT 100");
 ```
 ### Events
 _**Note:** You can only run events after the [required libraries](/cartodb-platform/torque/torquejs-getting-started/#advanced-torquejs-libraries) are loaded. Otherwise, the [interaction methods](/cartodb-platform/torque/torque-interaction-methods/) will not work._
 Events in Torque follow the format:
 ```js
 torqueLayer.on('event-type', function([callback_obj]) {
  // do something
 });
 ```
 Events | Callback Object | Description
 ---|---|---
 `change:steps` | current step | When a map changes steps, this event is triggered
 `change:time` | current time, step number | When a map changes time, this event is triggered
 `play` | none | Triggered when the Torque layer is played
 `pause` | none | Triggered when the Torque layer is paused
 `stop` | none | Triggered when the Torque layer is stopped
 `load` | none | Triggered when the Torque layer is loaded
 #### Example
 An event example to print the current step to the console log.
 ```js
 torqueLayer.on('change:steps', function(step) {
  // do something with step
  console.log('Current step is ' + step);
 });
 ```
 ## Google Maps Layers
 ### GMapsTorqueLayer(_options_)
 This class does exactly the same as ``L.TorqueLayer`` but using Google Maps instead. The main difference is that this class
 is not a layer but is an overlay, so in order to add it to the a map use, ``layer.setMap`` instead of ``overlayMapTypes``. See the [Overlay View](https://developers.google.com/maps/documentation/javascript/reference#OverlayView) reference in Google Maps API doc.
 #### Options
 Name | Description
 --- | ---
 map | A google.maps.Map instance
--- a/docs/guides/03-torque-interaction-methods.md
+++ b/docs/guides/03-torque-interaction-methods.md
@ -1,14 +1,17 @@
-## Advanced Torque.js Interaction Methods
+# Advanced Torque.js Interaction Methods
-### Torque Layers
+_**Note:** Before applying Torque.js interaction methods, you must first load the [required libraries](http://docs.cartodb.com/cartodb-platform/torque/torquejs-getting-started/#advanced-torquejs-libraries)_.
 ## Torque Layers
 While you can add multiple layers with Torque.js, this is not recommended as it effects performance.
-#### Torque Layer Source Object (_type: 'torque'_)
+### Torque Layer Source Object (_type: 'torque'_)
 This layer source object is used for Torque maps. Note that it does not allow sublayers.
-##### Example
+#### Example
 ```javascript
 {
@ -24,12 +27,12 @@ This layer source object is used for Torque maps. Note that it does not allow su
 ```
-### Interaction Methods for a Torque Layer
+## Interaction Methods for a Torque Layer
 Used to create an animated torque layer with customized settings.
 ```javascript
-// initialize a torque layer that uses the CARTO account details and SQL API to pull in data
+// initialize a torque layer that uses the CartoDB account details and SQL API to pull in data
 var torqueLayer = new L.TorqueLayer({
  user : 'viz2',
  table : 'ow',
@ -37,46 +40,46 @@ var torqueLayer = new L.TorqueLayer({
 });
 ```
-#### getValueForPos(_x, y[, step]_)
+### getValueForPos(_x, y[, step]_)
-##### Arguments
+#### Arguments
 Name | Description
 --- | --- 
 `getValueForPos(_x, y[, step]_)` |  Allows to get the value for the coordinate (in map reference system) for a concrete step. If a step is not specified, the animation step is used. Use caution, as this method increases CPU usage
-##### Returns
+#### Returns
 An object, such as a { bbox:[], value: VALUE } if there is value for the pos, otherwise, it is null. 
 It returns the value from the raster data, not the rendered data.
-#### getValueForBBox(_xstart, ystart, xend, yend_)
+### getValueForBBox(_xstart, ystart, xend, yend_)
-##### Arguments
+#### Arguments
 Name | Description
 --- | --- 
 `getValueForBBox(_xstart, ystart, xend, yend_)` |  An accumulated numerical value from all the torque areas, within the specified bounds
-##### Returns
+#### Returns
 Returns a number.
-#### getActivePointsBBox(_step_)
+### getActivePointsBBox(_step_)
-##### Arguments
+#### Arguments
 Name | Description
 --- | --- 
 `getActivePointsBBox(_step_)` |  The list of bounding boxes active for `step`
-##### Returns
+#### Returns
 Returns a list of values.
-#### invalidate()
+### invalidate()
-##### Arguments
+#### Arguments
 Name | Description
 --- | --- 
@ -84,7 +87,7 @@ Name | Description
 **Tip:** All of these interaction methods are available for Google Map layers, with the exception of `invalidate`.
-##### Example of Interaction Methods for a Torque Layer
+#### Example of Interaction Methods for a Torque Layer
 ```javascript
 <script>
@ -120,7 +123,7 @@ var map = new L.Map('map', {
  zoom: 3
 });
 L.tileLayer('http://{s}.api.cartocdn.com/base-dark/{z}/{x}/{y}.png', {
-  attribution: 'CARTO'
+  attribution: 'CartoDB'
 }).addTo(map);
 var torqueLayer = new L.TorqueLayer({
  user : 'viz2',
--- a/doc/torque_time_slider.md
+++ b/doc/torque_time_slider.md
@ -0,0 +1,60 @@
 # Torque Time Slider
 You can use the `time_slider` option to show an animated time slider with Torque layers. This option is enabled by default when creating visualizations with [cartodb.createVis](http://docs.cartodb.com/cartodb-platform/cartodb-js/api-methods/#cartodbcreatevis) and [createLayer](http://docs.cartodb.com/cartodb-platform/cartodb-js/api-methods/#cartodbcreatelayermap-layersource--options--callback). Both require a map_id DOM object.
 **Enable / Disable the Torque Time Slider**
 Description | The Torque time slider is enabled by default, for your visualization or layer.
 Sample Torque.js Code | `{ time_slider: true });`
 Default Value | `true`, enabled by default.
 Available Values | See [boolean](http://docs.cartodb.com/cartodb-platform/cartocss/properties/#boolean).
 Related Examples | To disable the time slider option, use `time_slider: false`. See [No Torque Time Slider - Example Code](http://bl.ocks.org/michellechandra/081ca7160a8c782266d2).<br/><br/>For a code example about how to use the `time_slider` option to modify a Torque map, see [Torque with a Custom Time Slider](http://bl.ocks.org/csobier/cebdd47242d7ca98ec5e).
 **Note:** The `time_slider` option is specific for Torque.js only. All the other CartoDB.js options are also supported for Torque.js. For the complete list of arguments, options, and returns, see [CartoDB.js API Methods](http://docs.cartodb.com/cartodb-platform/cartodb-js/api-methods/#api-methods).
 ## Customize Animation for your Time Slider
 You can customize the animation of your Torque time slider by editing the `-torque-frame-count` and `-torque-animation-duration` CartoCSS properties. (Optionally, you can create a [CartoDB.js](http://docs.cartodb.com/cartodb-platform/cartodb-js/api-methods/#api-methods) map to create a custom time slider). This section also describes how time interval data is aggregated, and describes the formula used to calculate time buckets.
 - [`-torque-frame-count`](http://docs.cartodb.com/cartodb-platform/cartocss/properties-for-torque/#torque-frame-count-number) specifies the number of animation steps/frames in your torque animation. You can change the time slider timestamp by adjusting the number of steps.<br /><br />**Tip:** This is the _Steps_ option from the [Torque wizard](/cartodb-editor/maps/#torque) of the CartDB Editor.
 - [`-torque-animation-duration`](http://docs.cartodb.com/cartodb-platform/cartocss/properties-for-torque/#torque-animation-duration-number) specifies the length of time for your animation, in seconds. You can adjust the duration of the animation as needed.<br /><br />**Tip:** This is the _Duration (secs)_ option from the [Torque wizard](/cartodb-editor/maps/#torque) of the CartoDB Editor.
 ### Aggregating Time Interval Data
 Before customizing the time slider, you should understand how Torque time interval data is calculated. Torque aggregates time (rather than use an exact start time and end from your column fields). Torque calculates the time interval as follows:
 - Reads the first date/time stamp from your dataset
 - Reads the last date/time stamp to from your dataset
 - Aggregates the time period based on the first and last date/time stamp (including seconds)
 - Once the time interval is defined, it breaks the time period up in smaller "buckets"
 - The number of buckets is based on the number of [Steps](http://docs.cartodb.com/cartodb-platform/cartocss/properties-for-torque/#torque-frame-count-number) you select for your Torque map
 - Each bucket, or step, is one animation frame
 Thus, the start and end time for each bucket depends on the number of divided steps (not a specific start time or end time that you entered). 
 **Note:** If you are creating Torque maps with the CartoDB Editor, the date format of the Torque time slider is automatically calculated by CartoDB and cannot be edited. See [Calculating the Time Slider in the CartoDB Editor](#calculating-the-time-slider-in-the-cartodb-editor) for more details.
 ### Formula for Calculating Time Buckets
 The following formula can help you calculate the number of steps for your Torque data.
 `time = times.start + (times.end - times.start)*(step/total_steps);`
 Where:
 - `time` = time at each hop
 - `times.start` = the earliest time in your date/time column
 - `times.end` = the latest time in your date/time column
 The Torque time slider displays these buckets of time, animating the entire sequence of your dataset, and divides the time according to the number of specified steps. You can alter the [duration](http://docs.cartodb.com/cartodb-platform/cartocss/properties-for-torque/#torque-animation-duration-number) of the animation, and adjust the time slider timestamp with the number of [Steps](http://docs.cartodb.com/cartodb-platform/cartocss/properties-for-torque/#torque-frame-count-number).
 #### Calculating the Time Slider in the CartoDB Editor
 When creating Torque maps with the CartoDB Editor, the date format of the Torque time slider is automatically calculated by CartoDB, depending on the range of time in your dataset. It cannot be edited. If your data contains the following range of time, the time slider displays as described:
 - Time range is _less than one day_, the time slider displays the _time_
 - Time range is _less than three days_, the time slider displays the _day and time_
 - Time range is _more than three days, but less than a year_, the time slider displays the _month/day/year_
 - Time range is _more than a year_, the time slider displays the _month/year_
--- a/docs/examples/examples.json
+++ b/docs/examples/examples.json
@ -1,57 +0,0 @@
 {
    "main": {
        "file": "static_bubble_map.html"
    },
    "categories": [
        {
            "title": "Static",
            "samples": [
                {
                    "title": "Bubble Map",
                    "desc": "",
                    "file": "static_bubble_map.html"
                },
                {
                    "title": "Heatmap",
                    "desc": "",
                    "file": "static_heat_map.html"
                },
                {
                    "title": "Heatmap Simple",
                    "desc": "",
                    "file": "static_heat_map_simple.html"
                }
            ]
        },
        {
            "title": "Misc",
            "samples": [
                {
                    "title": "Light Bright",
                    "desc": "",
                    "file": "light_bright.html"
                },
                {
                    "title": "Dual Encode",
                    "desc": "",
                    "file": "dual_encode.html"
                },
                {
                    "title": "Navy Ships GMaps",
                    "desc": "",
                    "file": "navy_gmaps.html"
                },
                {
                    "title": "Navy Ships Leaflet",
                    "desc": "",
                    "file": "navy_leaflet.html"
                },
                {
                    "title": "Navy Ships OpenLayers",
                    "desc": "",
                    "file": "navy_ol.html"
                }
            ]
        }
    ]
 }
--- a/docs/examples/navy_ol.html
+++ b/docs/examples/navy_ol.html
@ -1,75 +0,0 @@
 <!DOCTYPE html>
 <html>
 <head lang="en">
    <meta charset="UTF-8">
    <title>CartoDb Torque Layer Example</title>
    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/ol3/3.17.1/ol.css" type="text/css">
    <script src="https://cdnjs.cloudflare.com/ajax/libs/ol3/3.17.1/ol.js"></script>
    <style>
        #map, html, body {
            width: 100%; height: 100%; padding: 0; margin: 0;
        }
    </style>
 </head>
 <body>
    <div id="map"></div>
    <script src="https://libs.cartocdn.com/torque.js/2.16.5/torque.full.js"  type="application/javascript" charset="utf-8"></script>
    <script>
        // define the torque layer style using cartocss
        var CARTOCSS = [
            'Map {',
            '-torque-time-attribute: "date";',
            '-torque-aggregation-function: "count(cartodb_id)";',
            '-torque-frame-count: 760;',
            '-torque-animation-duration: 15;',
            '-torque-resolution: 2',
            '}',
            '#layer {',
            '  marker-width: 3;',
            '  marker-fill-opacity: 0.8;',
            '  marker-fill: #FEE391; ',
            '  comp-op: "lighten";',
            '  [value > 2] { marker-fill: #FEC44F; }',
            '  [value > 3] { marker-fill: #FE9929; }',
            '  [value > 4] { marker-fill: #EC7014; }',
            '  [value > 5] { marker-fill: #CC4C02; }',
            '  [value > 6] { marker-fill: #993404; }',
            '  [value > 7] { marker-fill: #662506; }',
            '  [frame-offset = 1] { marker-width: 10; marker-fill-opacity: 0.05;}',
            '  [frame-offset = 2] { marker-width: 15; marker-fill-opacity: 0.02;}',
            '}'
        ].join('\n');
        var map = new ol.Map({
            target: "map",
            view: new ol.View({
                center: [40, 0],
                zoom: 3
            }),
            layers: [
                new ol.layer.Tile({
                    source: new ol.source.XYZ({ url: 'https://basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png'})
                })
            ],
            interactions: ol.interaction.defaults({
                dragPan: false
            }).extend([
                new ol.interaction.DragPan({kinetic: false})
            ])
        });
        var torqueLayer = new ol.TorqueLayer({
            user       : 'viz2',
            table      : 'ow',
            cartocss: CARTOCSS,
            tiler_protocol: 'https',
            tiler_port: 443
        });
        torqueLayer.onAdd(map);
        torqueLayer.play()
    </script>
 </body>
 </html>
--- a/docs/guides/01-getting-started.md
+++ b/docs/guides/01-getting-started.md
@ -1,77 +0,0 @@
 ## Getting Started
 Although the most straightforward way to use Torque is through either CARTO Builder, or by passing the layer's viz.json to [CARTO.js]({{site.cartojs_docs}}/), many use cases work best with the standalone Torque.js. Assuming you have a public dataset with a `date` column, it is really simple to create an animated map with the library. First, you need to have a Leaflet map prepared in an HTML page:
 ```html
  <link rel="stylesheet" href="http://cdn.leafletjs.com/leaflet/v0.7.7/leaflet.css" />
  <body>
    <div id="map"></div>
    <script src="http://cdn.leafletjs.com/leaflet/v0.7.7/leaflet.js"></script>
    <script>
      var map = new L.Map('map', {
        zoomControl: true,
        center: [40, 0],
        zoom: 3
      });
      L.tileLayer('http://{s}.api.cartocdn.com/base-dark/{z}/{x}/{y}.png', {
        attribution: 'CARTO'
      }).addTo(map);
    </script>
  </body>
 ```
 This HTML file automatically generates the Torque.js library, which includes any Torque dependencies. For Torque to work with your table, you only need a username, the name of the table, and a [CartoCSS]({{site.styling_cartocss}}/) string to style the map. Leaflet's method `addTo` adds the Torque layer to the map. `play` runs the animation with the options specified in the CartoCSS properties.
 ```html
  <script>
    var CARTOCSS = [
      'Map {',
      '-torque-time-attribute: "date";',
      '-torque-aggregation-function: "count(cartodb_id)";',
      '-torque-frame-count: 760;',
      '-torque-animation-duration: 15;',
      '-torque-resolution: 2',
      '}',
      '#layer {',
      '  marker-width: 3;',
      '  marker-fill-opacity: 0.8;',
      '  marker-fill: #FEE391; ',
      '  comp-op: "lighten";',
      '}'
    ].join('\n');
    var torqueLayer = new L.TorqueLayer({
      user       : 'your_username',
      table      : 'your_table_name',
      cartocss: CARTOCSS
    });
    torqueLayer.addTo(map);
    torqueLayer.play()
  </script>
 ```
 You can use any kind of tile source outside CARTO, by specifying the location of a [valid TileJSON](https://github.com/mapbox/tilejson-spec) file:
 ```javascript
  var torqueLayer = new L.TorqueLayer({
    tileJSON: 'http://url.to/tile.json'
    cartocss: CARTOCSS
  });
 ```
 Optionally, it is also possible to use a custom SQL query for your visualization:
 ```javascript
  var torqueLayer = new L.TorqueLayer({
    user       : 'your_username',
    table      : 'your_table_name',
    sql_query  : 'SELECT * FROM your_table_name WHERE whatever'
    cartocss: CARTOCSS
  });
 ```
 Like in a video player, you can use animation control methods such as `play`, `stop` and `pause` at any point. Torque's animator fires a `change:time` event each time the animation "ticks" to the next frame, and there are a number of properties and methods that can be run during playback, which are detailed in the [API reference]({{site.torque_docs}}/reference/). At any point, for example, the styling of the layer's markers can be changed using the `layer.setCartoCSS('##style##')`.
 ### Usage Examples
 The best way to start learning about the library is by taking a look at the [examples section]({{site.torque_docs}}/examples/).
--- a/docs/guides/04-torque-time-slider.md
+++ b/docs/guides/04-torque-time-slider.md
@ -1,60 +0,0 @@
 ## Torque Time Slider
 You can use the `time_slider` option to show an animated time slider with Torque layers. This option is enabled by default when creating visualizations with [cartodb.createVis]({{site.cartojs_docs}}/v3/reference/#cartodbcreatevis) and [createLayer]({{site.cartojs_docs}}/v3/reference/#cartodbcreatelayermap-layersource--options--callback). Both require a map_id DOM object.
 **Enable / Disable the Torque Time Slider**
 Description | The Torque time slider is enabled by default, for your visualization or layer.
 Sample Torque.js Code | `{ time_slider: true });`
 Default Value | `true`, enabled by default.
 Available Values | See [boolean]({{site.styling_cartocss}}/#boolean).
 Related Examples | To disable the time slider option, use `time_slider: false`. See [No Torque Time Slider - Example Code](http://bl.ocks.org/michellechandra/081ca7160a8c782266d2).<br/><br/>For a code example about how to use the `time_slider` option to modify a Torque map, see [Torque with a Custom Time Slider](http://bl.ocks.org/csobier/cebdd47242d7ca98ec5e).
 **Note:** The `time_slider` option is specific for Torque.js only. All the other CARTO.js options are also supported for Torque.js. For the complete list of arguments, options, and returns, see [CARTO.js API Methods]({{site.cartojs_docs}}/v3/reference/#api-methods).
 ### Customize Animation for your Time Slider
 You can customize the animation of your Torque time slider by editing the `-torque-frame-count` and `-torque-animation-duration` CartoCSS properties. (Optionally, you can create a [CARTO.js]({{site.cartojs_docs}}/v3/reference/#api-methods) map to create a custom time slider). This section also describes how time interval data is aggregated, and describes the formula used to calculate time buckets.
 - [`-torque-frame-count`]({{site.styling_cartocss}}/#-torque-frame-count-number) specifies the number of animation steps/frames in your torque animation. You can change the time slider timestamp by adjusting the number of steps.<br /><br />**Tip:** In CARTO Builder, this is the STEPS value when the style is ANIMATED.
 - [`-torque-animation-duration`]({{site.styling_cartocss}}/#-torque-animation-duration-number) specifies the length of time for your animation, in seconds. You can adjust the duration of the animation as needed.<br /><br />**Tip:** In CARTO Builder, this is the DURATION value when the style is ANIMATED.
 #### Aggregating Time Interval Data
 Before customizing the time slider, you should understand how Torque time interval data is calculated. Torque aggregates time (rather than use an exact start time and end from your column fields). Torque calculates the time interval as follows:
 - Reads the first date/time stamp from your dataset
 - Reads the last date/time stamp to from your dataset
 - Aggregates the time period based on the first and last date/time stamp (including seconds)
 - Once the time interval is defined, it breaks the time period up in smaller "buckets"
 - The number of buckets is based on the number of [Steps]({{site.styling_cartocss}}/#-torque-frame-count-number) you select for your Torque map
 - Each bucket, or step, is one animation frame
 Thus, the start and end time for each bucket depends on the number of divided steps (not a specific start time or end time that you entered). 
 **Note:** If you are creating Torque maps with CARTO Builder, the date format of the Torque time slider is automatically calculated by CARTO and cannot be edited. See [Calculating the Time Slider in CARTO Builder](#calculating-the-time-slider-in-carto-builder) for more details.
 #### Formula for Calculating Time Buckets
 The following formula can help you calculate the number of steps for your Torque data.
 `time = times.start + (times.end - times.start)*(step/total_steps);`
 Where:
 - `time` = time at each hop
 - `times.start` = the earliest time in your date/time column
 - `times.end` = the latest time in your date/time column
 The Torque time slider displays these buckets of time, animating the entire sequence of your dataset, and divides the time according to the number of specified steps. You can alter the [duration]({{site.styling_cartocss}}/#-torque-animation-duration-number) of the animation, and adjust the time slider timestamp with the number of [Steps]({{site.styling_cartocss}}/#-torque-frame-count-number).
 ##### Calculating the Time Slider in CARTO Builder
 When creating Torque maps with CARTO Builder, the date format of the Torque time slider is automatically calculated by CARTO, depending on the range of time in your dataset. It cannot be edited. If your data contains the following range of time, the time slider displays as described:
 - Time range is _less than one day_, the time slider displays the _time_
 - Time range is _less than three days_, the time slider displays the _day and time_
 - Time range is _more than three days, but less than a year_, the time slider displays the _month/day/year_
 - Time range is _more than a year_, the time slider displays the _month/year_
--- a/docs/guides/05-how-spatial-aggregation-works.md
+++ b/docs/guides/05-how-spatial-aggregation-works.md
@ -1,69 +0,0 @@
 ## How spatial aggregation works
 When the Torque library renders points, it does not render exactly the same points you have in the database; instead it aggregates the points in clusters in order to speed up rendering and data transfer.
 So imagine you have this CartoCSS:
 ```css
 Map {
  -torque-aggregation-function:"count(cartodb_id)";
  -torque-resolution: 2;
 }
 ```
 This means that for the current zoom level, Torque will fetch points in clusters of 2x2 pixels. Every cluster has a value calculated by the function defined after ``-torque-aggregation-function``. In the case above, the value will be the number of points inside that cluster. That value can be accessed from CartoCSS using the variable `value`.
 Every cluster is renderer as a point.
 Given that you can do:
 ```css
 #layer {
 [value > 1] { marker-fill: #000; }
 [value > 4] { marker-fill: #400; }
 [value > 16] { marker-fill: #800; }
 [value > 32] { marker-fill: #F00; }
 }
 ```
 This would render the point with different colors depending on the number of points inside it.
 ## Can I use strings with Torque?
 In general you can **not** do:
 ```css
 [column = 'mytext'] { marker-fill: red; }
 ```
 There are two reasons for this limitation:
  - cluster does not contain values for all the columns, you can only use ``value`` variable
  - you would need to use an aggregation function for strings
 So how could I use strings column with Torque?
 Imagine you have a string column (`team`) with two values, "team A" and "team B", and you want to color "team A" points to be red and "team B" to be blue, you could add a new column on the fly:
 ```javascript
 torqueLayer.setSQL("select *, (CASE WHEN team='team A' THEN 1 ELSE 2 END) as team_n from table");
 ```
 and then apply this CartoCSS:
 ```css
 Map {
  ...
  -torque-aggregation-function: "round(avg(team_n))";
  ...
 }
 #layer {
  ...
  marker-fill: #FF0000;
  // avg of 1 and 2
  [value > 1.5] { marker-fill: #0000FF; }
  ...
 }
 ```      
 **Tip:** CartoCSS is one the tools of the CARTO platform. You can learn more about the different [components of CARTO platform]({{site.fundamental_docs}}/components/), or directly dig into [CartoCSS]({{site.styling_cartocss}}/) details.
--- a/docs/img/image
+++ b/docs/img/image
@ -1 +0,0 @@
--- a/docs/reference/01-introduction.md
+++ b/docs/reference/01-introduction.md
@ -1,5 +0,0 @@
 ## Introduction
 Torque.js is an efficient and stylish rendering method to animate your data.
 The contents described in this document are subject to CARTO's [Terms of Service](https://carto.com/legal/)
--- a/docs/reference/02-versioning.md
+++ b/docs/reference/02-versioning.md
@ -1,3 +0,0 @@
 ## Versioning
 Torque.js uses [Semantic Versioning](http://semver.org/). View our Github repository to find tags for each [release](https://github.com/CartoDB/torque/releases).
--- a/docs/reference/03-L.TorqueLayer.md
+++ b/docs/reference/03-L.TorqueLayer.md
@ -1,28 +0,0 @@
 ## L.TorqueLayer
 A layer to be added to a Leaflet map. It works as a regular tiled layer within the Leaflet tile pane, but instead of containing `<img>` elements, it's composed of a single [`<canvas>`](https://developer.mozilla.org/en-US/docs/Web/API/Canvas_API) where all markers are drawn.
 **Example:**
 ```javascript
 var torqueLayer = new L.TorqueLayer({
  user: 'viz2',
  table: 'ow',
  cartocss: '<cartocss here>'
 });
 map.addLayer(torqueLayer);
 ```
 ### Options
 Name | Description
 --- | ---
 cartocss | A string object, the CartoCSS style for the map. Default value is  ```null```
 loop | A boolean object that defines the animation loop. Default value is ```true```. If ```false```, the animation is paused when it reaches the last frame
 resolution | Spatial resolution in pixels. A resolution of 1 means no spatial aggregation of the data. Its value must be a power of 2
 steps | Number of steps that the animation is divided into
 animationDuration | Duration, in seconds, of the animation
 zIndex | Z-Index CSS property of the layer
 attribution | Attribution to be added in the bottom right of the map
 maxZoom | Maximum zoom for the layer. 
 tileSize | Size, in pixels of the tiles
--- a/docs/reference/04-using-a-CARTO-table-directly.md
+++ b/docs/reference/04-using-a-CARTO-table-directly.md
@ -1,6 +0,0 @@
 ## Using a CARTO table directly
 Name | Description
 --- | ---
 user | A string object, your CARTO [account name](https://carto.com/docs/carto-editor/your-account/#account). Default value is  ```null```
 table | A string object, the CARTO table name where data is found (also known as a dataset.) Default value is  ```null```
--- a/docs/reference/05-using-a-custom-SQL-query.md
+++ b/docs/reference/05-using-a-custom-SQL-query.md
@ -1,5 +0,0 @@
 ## Using a custom SQL query
 Name | Description
 --- | ---
 query | A string object, the SQL query to be performed to fetch the data. Default value is ```null```.<br/><br/>You must use this param or table, but not at the same time
 **Tip:** For a Torque category layer that is created dynamically with `cartodb.createLayer`, the SQL query must explicitly include how to build the torque_category column. You must include both the `sql` and `table_name` parameters. See this [createLayer with torque category layer](https://gist.github.com/danicarrion/dcaf6f00a71aa55134b4) example.
--- a/docs/reference/06-providing-a-TileJSON-file.md
+++ b/docs/reference/06-providing-a-TileJSON-file.md
@ -1,9 +0,0 @@
 ## Providing a TileJSON file
 Name | Description
 --- | ---
 tileJSON | A URL pointing to a valid [TileJSON](https://github.com/mapbox/tilejson-spec) file from which to get the Torque tile templates
 Add Comment
--- a/docs/reference/07-time-methods.md
+++ b/docs/reference/07-time-methods.md
@ -1,14 +0,0 @@
 ## Time Methods
 Method | Options | Returns | Description |
 ---|---|---|---|
 `setStep(step)` | `time numeric` | `this` | the value must be between 0 and the total number of `steps` in the animation
 `play()` | | `this` | starts the animation
 `stop()` | | `this` | stops the animation and set time to step 0
 `pause()` | | `this` | stops the animation but keep the current time (play enables the animation again)
 `toggle()` | | `this` | toggles (pause/play) the animation
 `getStep()` | | current animation step (integer) | gets the current animation step. A step is considered an animation frame
 `getTime()` | | current animation time (Date) | gets the real animation time
 `isRunning()` | | `true`/`false` | describes whether the Torque layer is playing or is stopped
 **Note:** Torque.js interprets the beginning and ending date/time from your "Time Column" as one block, then divides that up into [Steps]({{site.styling_cartocss}}/#-torque-frame-count-number), depending on the number you set. It does not necessarily draw one frame for each row.
--- a/docs/reference/08-layer-control-methods.md
+++ b/docs/reference/08-layer-control-methods.md
@ -1,6 +0,0 @@
 ## Layer Control Methods
 Method | Options | Returns | Description
 ---|---|---|---
 `hide()` | none | `this` | hides the Torque layer
 `show()` | none| `this` | shows the Torque layer
--- a/docs/reference/09-style-methods.md
+++ b/docs/reference/09-style-methods.md
@ -1,33 +0,0 @@
 ## Style Methods
 Method | Options | Returns | Description
 ---|---|---|---|
 `setCartoCSS(cartocss)` | `cartocss string` | `this` | style the map rendering using client-side CartoCSS (not available with [Named maps](https://carto.com/docs/{{site.mapsapi_docs}}/guides/named-maps//maps-api/named-maps/))
 Torque supports a limited subset of CartoCSS rules defined in the [torque-reference](https://github.com/cartodb/torque-reference). To see the full list of supported rules, read the [Torque CartoCSS documentation]({{site.styling_cartocss}}/#cartocss-properties-for-torque-style-maps). `value` and `zoom` variables can be used. `value` is the value of aggregation. `zoom` is the current zoom being rendered.
 TorqueLayer currently expects `marker` styling.
 **Example:**
 ```css
 /* This is how a minimal example of a stylesheet for a Torque visualisation would look like. */
 Map {
  -torque-time-attribute: "date";
  -torque-aggregation-function: "count(cartodb_id)";
  -torque-frame-count: 760;
  -torque-animation-duration: 15;
  -torque-resolution: 2;
 }
 #layer {
  marker-width: 3;
  marker-fill-opacity: 0.8;
  marker-fill: #FEE391; 
 }
 #layer[value = 4] { // Use of the value variable, generated by the function specified in -torque-aggregation-function
  marker-fill: #FABADA; 
 }
 #layer[zoom = 12] { // Use of the zoom variable
  marker-width: 10;
 }
 ```
--- a/docs/reference/10-data-methods.md
+++ b/docs/reference/10-data-methods.md
@ -1,12 +0,0 @@
 ## Data Methods
 Method | Options | Returns | Description
 ---|---|---|---
 `setSQL(sql statement)` | `SQL string` | `this` | Change the SQL on the data table (not available with named maps)
 `error(callback)` | `callback function with a list of errors as argument` | `this` | specifies a callback function to run if there are query errors
 **Example:**
 ```js
 // SQL Example to limit the data used in the Torque map.
 torqueLayer.setSQL("SELECT * FROM table LIMIT 100");
--- a/docs/reference/11-events.md
+++ b/docs/reference/11-events.md
@ -1,28 +0,0 @@
 ## Events
 Events in Torque follow the format:
 ```js
 torqueLayer.on('event-type', function([callback_obj]) {
  // do something
 });
 ```
 Events | Callback Object | Description
 ---|---|---
 `change:steps` | current step | When a map changes steps, this event is triggered
 `change:time` | current time, step number | When a map changes time, this event is triggered
 `play` | none | Triggered when the Torque layer is played
 `pause` | none | Triggered when the Torque layer is paused
 `stop` | none | Triggered when the Torque layer is stopped
 `load` | none | Triggered when the Torque layer is loaded
 **Example:**
 ```js
 // An event example to print the current step to the console log.
 torqueLayer.on('change:steps', function(step) {
  // do something with step
  console.log('Current step is ' + step);
 });
 ```
--- a/docs/reference/12-Google-maps-layers.md
+++ b/docs/reference/12-Google-maps-layers.md
@ -1,12 +0,0 @@
 ## Google Maps Layers
 ### GMapsTorqueLayer(_options_)
 This class does exactly the same as ``L.TorqueLayer`` but using Google Maps instead. The main difference is that this class
 is not a layer but is an overlay, so in order to add it to the a map use, ``layer.setMap`` instead of ``overlayMapTypes``. See the [Overlay View](https://developers.google.com/maps/documentation/javascript/reference#OverlayView) reference in Google Maps API doc.
 #### Options
 Name | Description
 --- | ---
 map | A google.maps.Map instance
--- a/docs/support/01-support-options.md
+++ b/docs/support/01-support-options.md
@ -1,36 +0,0 @@
 ## Support Options
 Feeling stuck? There are many ways to find help.
 * Ask a question on [GIS StackExchange](https://gis.stackexchange.com/questions/tagged/carto) using the `CARTO` tag.
 * [Report an issue](https://github.com/CartoDB/torque/issues/new) in Github.
 * Engine Plan customers have additional access to enterprise-level support through CARTO's support representatives.
 If you just want to describe an issue or share an idea, just <a class="typeform-share" href="https://cartohq.typeform.com/to/mH6RRl" data-mode="popup" target="_blank"> send your feedback</a>
 ### Issues on Github
 If you think you may have found a bug, or if you have a feature request that you would like to share with the Torque team, please [open an issue](https://github.com/CartoDB/torque/issues/new). 
 Before opening an issue, review the [contributing guidelines](https://github.com/CartoDB/torque/blob/master/CONTRIBUTING.md).
 ### Community support on GIS Stack Exchange
 GIS Stack Exchange is the most popular community in the geospatial industry. This is a collaboratively-edited question and answer site for geospatial programmers and technicians. It is a fantastic resource for asking technical questions about developing and maintaining your application.
 When posting a new question, please consider the following:
 * Read the GIS Stack Exchange [help](https://gis.stackexchange.com/help) and [how to ask](https://gis.stackexchange.com/help/how-to-ask) pages for guidelines and tips about posting questions.
 * Be very clear about your question in the subject. A clear explanation helps those trying to answer your question, as well as those who may be looking for information in the future.
 * Be informative in your post. Details, code snippets, logs, screenshots, etc. help others to understand your problem.
 * Use code that demonstrates the problem. It is very hard to debug errors without sample code to reproduce the problem.
 ### Engine Plan Customers
 Engine Plan customers have additional support options beyond general community support. As per your account Terms of Service, you have access to enterprise-level support through CARTO's support representatives available at [enterprise-support@carto.com](mailto:enterprise-support@carto.com)
 In order to speed up the resolution of your issue, provide as much information as possible (even if it is a link from community support). This allows our engineers to investigate your problem as soon as possible.
 If you are not yet CARTO customer, browse our [plans & pricing](https://carto.com/pricing/) and find the right plan for you.
--- a/docs/support/02-contribute.md
+++ b/docs/support/02-contribute.md
@ -1,36 +0,0 @@
 ## Contribute
 CARTO platform is an open-source ecosystem. You can read about the [fundamentals]({{site.fundamental_docs}}/components/) of CARTO architecture and its components.
 We are more than happy to receive your contributions to the code and the documentation as well.
 ## Filling a ticket
 If you want to open a new issue in our repository, please follow these instructions:
 1. Descriptive title.
 2. Write a good description, it always helps.
 3. Specify the steps to reproduce the problem.
 4. Try to add an example showing the problem.
 ## Contributing code
 Best part of open source, collaborate in Torque.js code!. We like hearing from you, so if you have any bug fixed, or a new feature ready to be merged, those are the steps you should follow:
 1. Fork the repository.
 2. Create a new branch in your forked repository.
 3. Commit your changes. Add new tests if it is necessary.
 4. Open a pull request.
 5. Any of the maintainers will take a look.
 6. If everything works, it will merged and released \o/.
 If you want more detailed information, this [GitHub guide](https://guides.github.com/activities/contributing-to-open-source/) is a must.
 ## Completing documentation
 Torque.js documentation is located in ```docs/```. That folder is the content that appears in the [Developer Center](http://carto.com/developers/torque-js/). Just follow the instructions described in [contributing code](#contributing-code) and after accepting your pull request, we will make it appear online :).
 **Tip:** A convenient, easy way of proposing changes in documentation is by using the GitHub editor directly on the web. You can easily create a branch with your changes and make a PR from there.
 ## Submitting contributions
 You will need to sign a Contributor License Agreement (CLA) before making a submission. [Learn more here](https://carto.com/contributions).
--- a/docs/examples/car.html
+++ b/docs/examples/car.html
@ -1,6 +1,6 @@
 <html>
-  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.3.4/leaflet.css" />
+  <link rel="stylesheet" href="vendor/leaflet.css" />
  <style>
    #map, html, body {
      width: 100%; height: 100%; padding: 0; margin: 0;
@ -9,8 +9,8 @@
  <body>
    <div id="map"></div>
-    <script src="https://maps.googleapis.com/maps/api/js?sensor=false"></script>
+    <script src="http://maps.googleapis.com/maps/api/js?sensor=false"></script>
-    <script src="https://libs.cartocdn.com/torque.js/2.16.5/torque.full.js"></script>
+    <script src="../dist/torque.full.uncompressed.js"></script>
    <script>
@ -55,8 +55,7 @@
        steps: 1024,
        blendmode  : 'lighter',
        animationDuration: 20,
-        map: map,
+        map: map
        tiler_protocol: 'https'
      });
    var DEFAULT_CARTOCSS = [
--- a/docs/examples/data_peek.html
+++ b/docs/examples/data_peek.html
@ -1,5 +1,5 @@
 <html>
-  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.3.4/leaflet.css" />
+  <link rel="stylesheet" href="vendor/leaflet.css" />
  <style>
    #map, html, body {
      width: 100%; height: 100%; padding: 0; margin: 0;
@ -8,8 +8,8 @@
  <body>
    <div id="map"></div>
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.3.4/leaflet.js"></script>
+    <script src="vendor/leaflet.js"></script>
-    <script src="https://libs.cartocdn.com/torque.js/2.16.5/torque.full.js"></script>
+    <script src="../dist/torque.full.uncompressed.js"></script>
    <script>
@ -24,7 +24,7 @@
          '}',
          '#layer {',
          'image-filters: colorize-alpha(blue, cyan, lightgreen, yellow , orange, red);',
-          'marker-file: url(https://s3.amazonaws.com/com.cartodb.assets.static/alphamarker.png);',
+          'marker-file: url(http://s3.amazonaws.com/com.cartodb.assets.static/alphamarker.png);',
          'marker-fill-opacity: 0.4;',
          'marker-width: 35;',
          '}'
@ -37,21 +37,17 @@
        zoom: 3
      });
-      L.tileLayer('https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png', {
+      L.tileLayer('http://{s}.api.cartocdn.com/base-dark/{z}/{x}/{y}.png', {
        attribution: 'CartoDB'
      }).addTo(map);
      var torqueLayer = new L.TorqueLayer({
        user       : 'fdansv',
        table      : 'snow',
-        cartocss: CARTOCSS,
+        cartocss: CARTOCSS
        tiler_protocol: 'https',
        tiler_port: 443,
        zIndex: 10
      });
      torqueLayer.addTo(map);
      torqueLayer.play();
      torqueLayer.bringToFront();
      var rect = document.createElement("div");
      var size = 50;
      rect.setAttribute('style', "position:absolute; background-color: #fff; width: 100px; height: 30px;");
--- a/docs/examples/dual_encode.html
+++ b/docs/examples/dual_encode.html
@ -4,7 +4,7 @@
    <title>Heat map simple | CartoDB.js</title>
    <meta name="viewport" content="initial-scale=1.0, user-scalable=no" />
    <meta http-equiv="content-type" content="text/html; charset=UTF-8"/>
-    <link rel="shortcut icon" href="https://cartodb.com/assets/favicon.ico" />
+    <link rel="shortcut icon" href="http://cartodb.com/assets/favicon.ico" />
    <style>
      html, body, #map {
        height: 100%;
@ -12,7 +12,7 @@
        margin: 0;
      }
    </style>
-    <link rel="stylesheet" href="https://libs.cartocdn.com/cartodb.js/v3/themes/css/cartodb.css" />
+    <link rel="stylesheet" href="http://libs.cartocdn.com/cartodb.js/v3/themes/css/cartodb.css" />
    <!--[if lte IE 8]>
      <link rel="stylesheet" href="http://libs.cartocdn.com/cartodb.js/v3/themes/css/cartodb.ie.css" />
    <![endif]-->
@ -95,7 +95,7 @@
    <div id="map"></div>
    <!-- include cartodb.js library -->
-    <script src="https://libs.cartocdn.com/cartodb.js/v3/cartodb.js"></script>
+    <script src="http://libs.cartocdn.com/cartodb.js/v3/cartodb.js"></script>
    <script>
      function main() {
@ -105,7 +105,7 @@
          zoom: 14
        });
-        var layer = L.tileLayer('https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png',{
+        var layer = L.tileLayer('http://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png',{
          attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://cartodb.com/attributions">CartoDB</a>'
        }).addTo(map);
@ -118,10 +118,6 @@
            user_name: "andrew",
            tile_style: $('#cartocss_template').html()
            }
        }, {
          https: true,
          tiler_protocol: 'https',
          tiler_port: 443
        }).done(function(layer) {
          map.addLayer(layer);
        });
--- a/docs/examples/leaflet_interaction.html
+++ b/docs/examples/leaflet_interaction.html
@ -1,5 +1,6 @@
 <html>
  <link rel="stylesheet" href="vendor/leaflet.css" />
  <style>
    #map, html, body {
      width: 100%; height: 100%; padding: 0; margin: 0;
@ -17,8 +18,8 @@
    <div id="map"></div>
    <div id="title">Average temperature collected by Britain's Royal Navy (1913-1925)</div>
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.3.4/leaflet.css" />
+    <link rel="stylesheet" href="http://cdn.leafletjs.com/leaflet-0.7.3/leaflet.css" />
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.3.4/leaflet.js"></script>
+    <script src="http://cdn.leafletjs.com/leaflet-0.7.3/leaflet.js"></script>
    <script src="../dist/torque.full.uncompressed.js"></script>
@ -56,17 +57,14 @@
        zoom: 3
      });
-      L.tileLayer('https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png', {
+      L.tileLayer('http://{s}.api.cartocdn.com/base-dark/{z}/{x}/{y}.png', {
        attribution: 'CartoDB'
-      }).addTo(map, true);
+      }).addTo(map);
      var torqueLayer = new L.TorqueLayer({
        user       : 'viz2',
        table      : 'ow',
-        cartocss: CARTOCSS,
+        cartocss: CARTOCSS
        tiler_protocol: 'https',
        tiler_port: 443,
        zIndex: 10
      });
      torqueLayer.addTo(map);
--- a/docs/examples/light_bright.html
+++ b/docs/examples/light_bright.html
@ -4,7 +4,7 @@
    <title>Light bright effect | CartoDB.js</title>
    <meta name="viewport" content="initial-scale=1.0, user-scalable=no" />
    <meta http-equiv="content-type" content="text/html; charset=UTF-8"/>
-    <link rel="shortcut icon" href="https://cartodb.com/assets/favicon.ico" />
+    <link rel="shortcut icon" href="http://cartodb.com/assets/favicon.ico" />
    <style>
      html, body, #map {
        height: 100%;
@ -12,7 +12,7 @@
        margin: 0;
      }
    </style>
-    <link rel="stylesheet" href="https://libs.cartocdn.com/cartodb.js/v3/themes/css/cartodb.css" />
+    <link rel="stylesheet" href="http://libs.cartocdn.com/cartodb.js/v3/themes/css/cartodb.css" />
    <!--[if lte IE 8]>
      <link rel="stylesheet" href="http://libs.cartocdn.com/cartodb.js/v3/themes/css/cartodb.ie.css" />
    <![endif]-->
@ -60,7 +60,7 @@
    <div id="map"></div>
    <!-- include cartodb.js library -->
-    <script src="https://libs.cartocdn.com/cartodb.js/v3/cartodb.js"></script>
+    <script src="http://libs.cartocdn.com/cartodb.js/v3/cartodb.js"></script>
    <script>
      function main() {
@ -69,7 +69,7 @@
          center: [-6.964483, 107.634506],
          zoom: 7
        });
-        var layer = L.tileLayer('https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png',{
+        var layer = L.tileLayer('http://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png',{
          attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://cartodb.com/attributions">CartoDB</a>'
        }).addTo(map);
@ -81,10 +81,6 @@
            user_name: "andrew",
            tile_style: $('#cartocss_template').html()
            }
        }, {
          https: true,
          tiler_protocol: 'https',
          tiler_port: 443
        }).done(function(layer) {
          map.addLayer(layer);
        });
--- a/docs/examples/navy_gmaps.html
+++ b/docs/examples/navy_gmaps.html
@ -8,8 +8,8 @@
    <div id="map"></div>
-    <script src="https://maps.googleapis.com/maps/api/js?sensor=false"></script>
+    <script src="http://maps.googleapis.com/maps/api/js?sensor=false"></script>
-    <script src="https://libs.cartocdn.com/torque.js/2.16.5/torque.full.js"  type="application/javascript" charset="utf-8"></script>
+    <script src="../dist/torque.full.uncompressed.js"></script>
    <script>
@ -75,8 +75,7 @@
        user       : 'viz2',
        table      : 'ow',
        cartocss: CARTOCSS,
-        tiler_protocol: 'https',
+        map: map
        tiler_port: 443
      });
      torqueLayer.error(function(err){
        for(error in err){
--- a/docs/examples/navy_leaflet.html
+++ b/docs/examples/navy_leaflet.html
@ -1,4 +1,5 @@
 <html>
  <link rel="stylesheet" href="vendor/leaflet.css" />
  <style>
    #map, html, body {
      width: 100%; height: 100%; padding: 0; margin: 0;
@ -7,9 +8,8 @@
  <body>
    <div id="map"></div>
-    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.3.4/leaflet.css" />
+    <script src="vendor/leaflet.js"></script>
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.3.4/leaflet.js"></script>
+    <script src="../dist/torque.full.uncompressed.js"></script>
    <script src="https://libs.cartocdn.com/torque.js/2.16.5/torque.full.js"  type="application/javascript" charset="utf-8"></script>
    <script>
@ -45,17 +45,14 @@
        zoom: 3
      });
-      L.tileLayer('https://{s}.basemaps.cartocdn.com/dark_all/{z}/{x}/{y}.png', {
+      L.tileLayer('http://{s}.api.cartocdn.com/base-dark/{z}/{x}/{y}.png', {
        attribution: 'CartoDB'
      }).addTo(map);
      var torqueLayer = new L.TorqueLayer({
        user       : 'viz2',
        table      : 'ow',
-        zIndex: 100,
+        cartocss: CARTOCSS
        cartocss: CARTOCSS,
        tiler_protocol: 'https',
        tiler_port: 443
      });
      torqueLayer.error(function(err){
        for(error in err){
--- a/docs/examples/render-range_leaflet.html
+++ b/docs/examples/render-range_leaflet.html
@ -1,5 +1,5 @@
 <html>
-  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.3.4/leaflet.css" />
+  <link rel="stylesheet" href="vendor/leaflet.css" />
  <style>
    #map, html, body {
      width: 100%; height: 100%; padding: 0; margin: 0;
@ -19,8 +19,8 @@
    </div>
    <div id="map"></div>
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.3.4/leaflet.js"></script>
+    <script src="vendor/leaflet.js"></script>
-    <script src="https://libs.cartocdn.com/torque.js/2.16.5/torque.full.js"></script>
+    <script src="../dist/torque.full.uncompressed.js"></script>
    <script>
@ -60,10 +60,7 @@
      var torqueLayer = new L.TorqueLayer({
        user: 'documentation',
        sql: 'SELECT s + 181 as cartodb_id, st_transform(ST_SetSRID (st_makepoint(s, 10*sin(s)), 4326), 3857) as the_geom_webmercator FROM generate_series(-180, 180, 1) as s',
-        cartocss: CARTOCSS,
+        cartocss: CARTOCSS
        tiler_protocol: 'https',
        tiler_port: 443,
        zIndex: 10
      });
      torqueLayer.error(console.warn);
      torqueLayer.addTo(map);
--- a/docs/examples/sql.html
+++ b/docs/examples/sql.html
--- a/docs/examples/static_bubble_map.html
+++ b/docs/examples/static_bubble_map.html
@ -4,7 +4,7 @@
    <title>Static bubble map | CartoDB.js</title>
    <meta name="viewport" content="initial-scale=1.0, user-scalable=no" />
    <meta http-equiv="content-type" content="text/html; charset=UTF-8"/>
-    <link rel="shortcut icon" href="https://cartodb.com/assets/favicon.ico" />
+    <link rel="shortcut icon" href="http://cartodb.com/assets/favicon.ico" />
    <style>
      html, body, #map {
        height: 100%;
@ -12,7 +12,7 @@
        margin: 0;
      }
    </style>
-    <link rel="stylesheet" href="https://libs.cartocdn.com/cartodb.js/v3/themes/css/cartodb.css" />
+    <link rel="stylesheet" href="http://libs.cartocdn.com/cartodb.js/v3/themes/css/cartodb.css" />
    <!--[if lte IE 8]>
      <link rel="stylesheet" href="http://libs.cartocdn.com/cartodb.js/v3/themes/css/cartodb.ie.css" />
    <![endif]-->
@ -57,7 +57,7 @@
    <div id="map"></div>
    <!-- include cartodb.js library -->
-    <script src="https://libs.cartocdn.com/cartodb.js/v3/cartodb.uncompressed.js"></script>
+    <script src="http://libs.cartocdn.com/cartodb.js/v3/cartodb.js"></script>
    <script>
      function main() {
@ -66,7 +66,7 @@
          center: [39.9304, 116.423239],
          zoom: 8
        });
-        var layer = L.tileLayer('https://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png',{
+        var layer = L.tileLayer('http://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png',{
          attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://cartodb.com/attributions">CartoDB</a>'
        }).addTo(map);
@ -78,10 +78,6 @@
            user_name: "andrew",
            tile_style: $('#cartocss_template').html()
            }
        }, {
          https: true,
          tiler_protocol: 'https',
          tiler_port: 443
        }).done(function(layer) {
          map.addLayer(layer);
        });
--- a/docs/examples/static_heat_map.html
+++ b/docs/examples/static_heat_map.html
@ -4,7 +4,7 @@
    <title>Torque heatmap | CartoDB.js</title>
    <meta name="viewport" content="initial-scale=1.0, user-scalable=no" />
    <meta http-equiv="content-type" content="text/html; charset=UTF-8"/>
-    <link rel="shortcut icon" href="https://cartodb.com/assets/favicon.ico" />
+    <link rel="shortcut icon" href="http://cartodb.com/assets/favicon.ico" />
    <style>
      html, body, #map {
        height: 100%;
@ -12,7 +12,7 @@
        margin: 0;
      }
    </style>
-    <link rel="stylesheet" href="https://libs.cartocdn.com/cartodb.js/v3/themes/css/cartodb.css" />
+    <link rel="stylesheet" href="http://libs.cartocdn.com/cartodb.js/v3/themes/css/cartodb.css" />
    <!--[if lte IE 8]>
      <link rel="stylesheet" href="http://libs.cartocdn.com/cartodb.js/v3/themes/css/cartodb.ie.css" />
    <![endif]-->
@ -54,7 +54,7 @@
    <div id="map"></div>
    <!-- include cartodb.js library -->
-    <script src="https://libs.cartocdn.com/cartodb.js/v3/cartodb.js"></script>
+    <script src="http://libs.cartocdn.com/cartodb.js/v3/cartodb.js"></script>
    <script>
      function main() {
@ -64,7 +64,7 @@
          zoom: 7
        });
-        var layer = L.tileLayer('https://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png',{
+        var layer = L.tileLayer('http://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png',{
          attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://cartodb.com/attributions">CartoDB</a>'
        }).addTo(map);
@ -77,10 +77,6 @@
            user_name: "andrew",
            tile_style: $('#cartocss_template').html()
            }
        }, {
          https: true,
          tiler_protocol: 'https',
          tiler_port: 443
        }).done(function(layer) {
          map.addLayer(layer);
        });
--- a/docs/examples/static_heat_map_simple.html
+++ b/docs/examples/static_heat_map_simple.html
@ -4,7 +4,7 @@
    <title>Heat map simple | CartoDB.js</title>
    <meta name="viewport" content="initial-scale=1.0, user-scalable=no" />
    <meta http-equiv="content-type" content="text/html; charset=UTF-8"/>
-    <link rel="shortcut icon" href="https://cartodb.com/assets/favicon.ico" />
+    <link rel="shortcut icon" href="http://cartodb.com/assets/favicon.ico" />
    <style>
      html, body, #map {
        height: 100%;
@ -12,7 +12,7 @@
        margin: 0;
      }
    </style>
-    <link rel="stylesheet" href="https://libs.cartocdn.com/cartodb.js/v3/themes/css/cartodb.css" />
+    <link rel="stylesheet" href="http://libs.cartocdn.com/cartodb.js/v3/themes/css/cartodb.css" />
    <!--[if lte IE 8]>
      <link rel="stylesheet" href="http://libs.cartocdn.com/cartodb.js/v3/themes/css/cartodb.ie.css" />
    <![endif]-->
@ -41,7 +41,7 @@
    <div id="map"></div>
    <!-- include cartodb.js library -->
-    <script src="https://libs.cartocdn.com/cartodb.js/v3/cartodb.js"></script>
+    <script src="http://libs.cartocdn.com/cartodb.js/v3/cartodb.js"></script>
    <script>
      function main() {
@ -51,7 +51,7 @@
          zoom: 7
        });
-        var layer = L.tileLayer('https://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png',{
+        var layer = L.tileLayer('http://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png',{
          attribution: '&copy; <a href="http://www.openstreetmap.org/copyright">OpenStreetMap</a> contributors, &copy; <a href="http://cartodb.com/attributions">CartoDB</a>'
        }).addTo(map);
@ -64,10 +64,6 @@
            user_name: "andrew",
            tile_style: $('#cartocss_template').html()
            }
        }, {
          https: true,
          tiler_protocol: 'https',
          tiler_port: 443
        }).done(function(layer) {
          map.addLayer(layer);
        });
--- a/docs/examples/tilejson.html
+++ b/docs/examples/tilejson.html
@ -1,5 +1,5 @@
 <html>
-  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.3.4/leaflet.css" />
+  <link rel="stylesheet" href="vendor/leaflet.css" />
  <style>
    #map, html, body {
      width: 100%; height: 100%; padding: 0; margin: 0;
@ -8,7 +8,7 @@
  <body>
    <div id="map"></div>
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.3.4/leaflet.js"></script>
+    <script src="vendor/leaflet.js"></script>
    <script src="../dist/torque.full.uncompressed.js"></script>
--- a/docs/examples/tilejson.json
+++ b/docs/examples/tilejson.json
--- a/examples/vendor/carto.js
+++ b/examples/vendor/carto.js
--- a/examples/vendor/codemirror.css
+++ b/examples/vendor/codemirror.css
@ -0,0 +1,263 @@
 /* BASICS */
 .CodeMirror {
  /* Set height, width, borders, and global font properties here */
  font-family: monospace;
  height: 300px;
 }
 .CodeMirror-scroll {
  /* Set scrolling behaviour here */
  overflow: auto;
 }
 /* PADDING */
 .CodeMirror-lines {
  padding: 4px 0; /* Vertical padding around content */
 }
 .CodeMirror pre {
  padding: 0 4px; /* Horizontal padding of content */
 }
 .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
  background-color: white; /* The little square between H and V scrollbars */
 }
 /* GUTTER */
 .CodeMirror-gutters {
  border-right: 1px solid #ddd;
  background-color: #f7f7f7;
  white-space: nowrap;
 }
 .CodeMirror-linenumbers {}
 .CodeMirror-linenumber {
  padding: 0 3px 0 5px;
  min-width: 20px;
  text-align: right;
  color: #999;
 }
 /* CURSOR */
 .CodeMirror div.CodeMirror-cursor {
  border-left: 1px solid black;
  z-index: 3;
 }
 /* Shown when moving in bi-directional text */
 .CodeMirror div.CodeMirror-secondarycursor {
  border-left: 1px solid silver;
 }
 .CodeMirror.cm-keymap-fat-cursor div.CodeMirror-cursor {
  width: auto;
  border: 0;
  background: #7e7;
  z-index: 1;
 }
 /* Can style cursor different in overwrite (non-insert) mode */
 .CodeMirror div.CodeMirror-cursor.CodeMirror-overwrite {}
 .cm-tab { display: inline-block; }
 /* DEFAULT THEME */
 .cm-s-default .cm-keyword {color: #708;}
 .cm-s-default .cm-atom {color: #219;}
 .cm-s-default .cm-number {color: #164;}
 .cm-s-default .cm-def {color: #00f;}
 .cm-s-default .cm-variable {color: black;}
 .cm-s-default .cm-variable-2 {color: #05a;}
 .cm-s-default .cm-variable-3 {color: #085;}
 .cm-s-default .cm-property {color: black;}
 .cm-s-default .cm-operator {color: black;}
 .cm-s-default .cm-comment {color: #a50;}
 .cm-s-default .cm-string {color: #a11;}
 .cm-s-default .cm-string-2 {color: #f50;}
 .cm-s-default .cm-meta {color: #555;}
 .cm-s-default .cm-error {color: #f00;}
 .cm-s-default .cm-qualifier {color: #555;}
 .cm-s-default .cm-builtin {color: #30a;}
 .cm-s-default .cm-bracket {color: #997;}
 .cm-s-default .cm-tag {color: #170;}
 .cm-s-default .cm-attribute {color: #00c;}
 .cm-s-default .cm-header {color: blue;}
 .cm-s-default .cm-quote {color: #090;}
 .cm-s-default .cm-hr {color: #999;}
 .cm-s-default .cm-link {color: #00c;}
 .cm-negative {color: #d44;}
 .cm-positive {color: #292;}
 .cm-header, .cm-strong {font-weight: bold;}
 .cm-em {font-style: italic;}
 .cm-link {text-decoration: underline;}
 .cm-invalidchar {color: #f00;}
 div.CodeMirror span.CodeMirror-matchingbracket {color: #0f0;}
 div.CodeMirror span.CodeMirror-nonmatchingbracket {color: #f22;}
 .CodeMirror-activeline-background {background: #e8f2ff;}
 /* STOP */
 /* The rest of this file contains styles related to the mechanics of
   the editor. You probably shouldn't touch them. */
 .CodeMirror {
  line-height: 1;
  position: relative;
  overflow: hidden;
  background: white;
  color: black;
 }
 .CodeMirror-scroll {
  /* 30px is the magic margin used to hide the element's real scrollbars */
  /* See overflow: hidden in .CodeMirror */
  margin-bottom: -30px; margin-right: -30px;
  padding-bottom: 30px; padding-right: 30px;
  height: 100%;
  outline: none; /* Prevent dragging from highlighting the element */
  position: relative;
  -moz-box-sizing: content-box;
  box-sizing: content-box;
 }
 .CodeMirror-sizer {
  position: relative;
 }
 /* The fake, visible scrollbars. Used to force redraw during scrolling
   before actuall scrolling happens, thus preventing shaking and
   flickering artifacts. */
 .CodeMirror-vscrollbar, .CodeMirror-hscrollbar, .CodeMirror-scrollbar-filler, .CodeMirror-gutter-filler {
  position: absolute;
  z-index: 6;
  display: none;
 }
 .CodeMirror-vscrollbar {
  right: 0; top: 0;
  overflow-x: hidden;
  overflow-y: scroll;
 }
 .CodeMirror-hscrollbar {
  bottom: 0; left: 0;
  overflow-y: hidden;
  overflow-x: scroll;
 }
 .CodeMirror-scrollbar-filler {
  right: 0; bottom: 0;
 }
 .CodeMirror-gutter-filler {
  left: 0; bottom: 0;
 }
 .CodeMirror-gutters {
  position: absolute; left: 0; top: 0;
  padding-bottom: 30px;
  z-index: 3;
 }
 .CodeMirror-gutter {
  white-space: normal;
  height: 100%;
  -moz-box-sizing: content-box;
  box-sizing: content-box;
  padding-bottom: 30px;
  margin-bottom: -32px;
  display: inline-block;
  /* Hack to make IE7 behave */
  *zoom:1;
  *display:inline;
 }
 .CodeMirror-gutter-elt {
  position: absolute;
  cursor: default;
  z-index: 4;
 }
 .CodeMirror-lines {
  cursor: text;
 }
 .CodeMirror pre {
  /* Reset some styles that the rest of the page might have set */
  -moz-border-radius: 0; -webkit-border-radius: 0; border-radius: 0;
  border-width: 0;
  background: transparent;
  font-family: inherit;
  font-size: inherit;
  margin: 0;
  white-space: pre;
  word-wrap: normal;
  line-height: inherit;
  color: inherit;
  z-index: 2;
  position: relative;
  overflow: visible;
 }
 .CodeMirror-wrap pre {
  word-wrap: break-word;
  white-space: pre-wrap;
  word-break: normal;
 }
 .CodeMirror-code pre {
  border-right: 30px solid transparent;
  width: -webkit-fit-content;
  width: -moz-fit-content;
  width: fit-content;
 }
 .CodeMirror-wrap .CodeMirror-code pre {
  border-right: none;
  width: auto;
 }
 .CodeMirror-linebackground {
  position: absolute;
  left: 0; right: 0; top: 0; bottom: 0;
  z-index: 0;
 }
 .CodeMirror-linewidget {
  position: relative;
  z-index: 2;
  overflow: auto;
 }
 .CodeMirror-widget {}
 .CodeMirror-wrap .CodeMirror-scroll {
  overflow-x: hidden;
 }
 .CodeMirror-measure {
  position: absolute;
  width: 100%;
  height: 0;
  overflow: hidden;
  visibility: hidden;
 }
 .CodeMirror-measure pre { position: static; }
 .CodeMirror div.CodeMirror-cursor {
  position: absolute;
  visibility: hidden;
  border-right: none;
  width: 0;
 }
 .CodeMirror-focused div.CodeMirror-cursor {
  visibility: visible;
 }
 .CodeMirror-selected { background: #d9d9d9; }
 .CodeMirror-focused .CodeMirror-selected { background: #d7d4f0; }
 .cm-searching {
  background: #ffa;
  background: rgba(255, 255, 0, .4);
 }
 /* IE7 hack to prevent it from returning funny offsetTops on the spans */
 .CodeMirror span { *vertical-align: text-bottom; }
@media print {
  /* Hide the cursor when printing */
  .CodeMirror div.CodeMirror-cursor {
    visibility: hidden;
  }
 }
--- a/examples/vendor/codemirror.js
+++ b/examples/vendor/codemirror.js
--- a/examples/vendor/css.js
+++ b/examples/vendor/css.js
@ -0,0 +1,639 @@
 CodeMirror.defineMode("css", function(config, parserConfig) {
  "use strict";
  if (!parserConfig.propertyKeywords) parserConfig = CodeMirror.resolveMode("text/css");
  var indentUnit = config.indentUnit || config.tabSize || 2,
      hooks = parserConfig.hooks || {},
      atMediaTypes = parserConfig.atMediaTypes || {},
      atMediaFeatures = parserConfig.atMediaFeatures || {},
      propertyKeywords = parserConfig.propertyKeywords || {},
      colorKeywords = parserConfig.colorKeywords || {},
      valueKeywords = parserConfig.valueKeywords || {},
      allowNested = !!parserConfig.allowNested,
      type = null;
  function ret(style, tp) { type = tp; return style; }
  function tokenBase(stream, state) {
    var ch = stream.next();
    if (hooks[ch]) {
      // result[0] is style and result[1] is type
      var result = hooks[ch](stream, state);
      if (result !== false) return result;
    }
    if (ch == "@") {stream.eatWhile(/[\w\\\-]/); return ret("def", stream.current());}
    else if (ch == "=") ret(null, "compare");
    else if ((ch == "~" || ch == "|") && stream.eat("=")) return ret(null, "compare");
    else if (ch == "\"" || ch == "'") {
      state.tokenize = tokenString(ch);
      return state.tokenize(stream, state);
    }
    else if (ch == "#") {
      stream.eatWhile(/[\w\\\-]/);
      return ret("atom", "hash");
    }
    else if (ch == "!") {
      stream.match(/^\s*\w*/);
      return ret("keyword", "important");
    }
    else if (/\d/.test(ch) || ch == "." && stream.eat(/\d/)) {
      stream.eatWhile(/[\w.%]/);
      return ret("number", "unit");
    }
    else if (ch === "-") {
      if (/\d/.test(stream.peek())) {
        stream.eatWhile(/[\w.%]/);
        return ret("number", "unit");
      } else if (stream.match(/^[^-]+-/)) {
        return ret("meta", "meta");
      }
    }
    else if (/[,+>*\/]/.test(ch)) {
      return ret(null, "select-op");
    }
    else if (ch == "." && stream.match(/^-?[_a-z][_a-z0-9-]*/i)) {
      return ret("qualifier", "qualifier");
    }
    else if (ch == ":") {
      return ret("operator", ch);
    }
    else if (/[;{}\[\]\(\)]/.test(ch)) {
      return ret(null, ch);
    }
    else if (ch == "u" && stream.match("rl(")) {
      stream.backUp(1);
      state.tokenize = tokenParenthesized;
      return ret("property", "variable");
    }
    else {
      stream.eatWhile(/[\w\\\-]/);
      return ret("property", "variable");
    }
  }
  function tokenString(quote, nonInclusive) {
    return function(stream, state) {
      var escaped = false, ch;
      while ((ch = stream.next()) != null) {
        if (ch == quote && !escaped)
          break;
        escaped = !escaped && ch == "\\";
      }
      if (!escaped) {
        if (nonInclusive) stream.backUp(1);
        state.tokenize = tokenBase;
      }
      return ret("string", "string");
    };
  }
  function tokenParenthesized(stream, state) {
    stream.next(); // Must be '('
    if (!stream.match(/\s*[\"\']/, false))
      state.tokenize = tokenString(")", true);
    else
      state.tokenize = tokenBase;
    return ret(null, "(");
  }
  return {
    startState: function(base) {
      return {tokenize: tokenBase,
              baseIndent: base || 0,
              stack: [],
              lastToken: null};
    },
    token: function(stream, state) {
      // Use these terms when applicable (see http://www.xanthir.com/blog/b4E50)
      //
      // rule** or **ruleset:
      // A selector + braces combo, or an at-rule.
      //
      // declaration block:
      // A sequence of declarations.
      //
      // declaration:
      // A property + colon + value combo.
      //
      // property value:
      // The entire value of a property.
      //
      // component value:
      // A single piece of a property value. Like the 5px in
      // text-shadow: 0 0 5px blue;. Can also refer to things that are
      // multiple terms, like the 1-4 terms that make up the background-size
      // portion of the background shorthand.
      //
      // term:
      // The basic unit of author-facing CSS, like a single number (5),
      // dimension (5px), string ("foo"), or function. Officially defined
      //  by the CSS 2.1 grammar (look for the 'term' production)
      //
      //
      // simple selector:
      // A single atomic selector, like a type selector, an attr selector, a
      // class selector, etc.
      //
      // compound selector:
      // One or more simple selectors without a combinator. div.example is
      // compound, div > .example is not.
      //
      // complex selector:
      // One or more compound selectors chained with combinators.
      //
      // combinator:
      // The parts of selectors that express relationships. There are four
      // currently - the space (descendant combinator), the greater-than
      // bracket (child combinator), the plus sign (next sibling combinator),
      // and the tilda (following sibling combinator).
      //
      // sequence of selectors:
      // One or more of the named type of selector chained with commas.
      state.tokenize = state.tokenize || tokenBase;
      if (state.tokenize == tokenBase && stream.eatSpace()) return null;
      var style = state.tokenize(stream, state);
      if (style && typeof style != "string") style = ret(style[0], style[1]);
      // Changing style returned based on context
      var context = state.stack[state.stack.length-1];
      if (style == "variable") {
        if (type == "variable-definition") state.stack.push("propertyValue");
        return state.lastToken = "variable-2";
      } else if (style == "property") {
        var word = stream.current().toLowerCase();
        if (context == "propertyValue") {
          if (valueKeywords.hasOwnProperty(word)) {
            style = "string-2";
          } else if (colorKeywords.hasOwnProperty(word)) {
            style = "keyword";
          } else {
            style = "variable-2";
          }
        } else if (context == "rule") {
          if (!propertyKeywords.hasOwnProperty(word)) {
            style += " error";
          }
        } else if (context == "block") {
          // if a value is present in both property, value, or color, the order
          // of preference is property -> color -> value
          if (propertyKeywords.hasOwnProperty(word)) {
            style = "property";
          } else if (colorKeywords.hasOwnProperty(word)) {
            style = "keyword";
          } else if (valueKeywords.hasOwnProperty(word)) {
            style = "string-2";
          } else {
            style = "tag";
          }
        } else if (!context || context == "@media{") {
          style = "tag";
        } else if (context == "@media") {
          if (atMediaTypes[stream.current()]) {
            style = "attribute"; // Known attribute
          } else if (/^(only|not)$/.test(word)) {
            style = "keyword";
          } else if (word == "and") {
            style = "error"; // "and" is only allowed in @mediaType
          } else if (atMediaFeatures.hasOwnProperty(word)) {
            style = "error"; // Known property, should be in @mediaType(
          } else {
            // Unknown, expecting keyword or attribute, assuming attribute
            style = "attribute error";
          }
        } else if (context == "@mediaType") {
          if (atMediaTypes.hasOwnProperty(word)) {
            style = "attribute";
          } else if (word == "and") {
            style = "operator";
          } else if (/^(only|not)$/.test(word)) {
            style = "error"; // Only allowed in @media
          } else {
            // Unknown attribute or property, but expecting property (preceded
            // by "and"). Should be in parentheses
            style = "error";
          }
        } else if (context == "@mediaType(") {
          if (propertyKeywords.hasOwnProperty(word)) {
            // do nothing, remains "property"
          } else if (atMediaTypes.hasOwnProperty(word)) {
            style = "error"; // Known property, should be in parentheses
          } else if (word == "and") {
            style = "operator";
          } else if (/^(only|not)$/.test(word)) {
            style = "error"; // Only allowed in @media
          } else {
            style += " error";
          }
        } else if (context == "@import") {
          style = "tag";
        } else {
          style = "error";
        }
      } else if (style == "atom") {
        if(!context || context == "@media{" || context == "block") {
          style = "builtin";
        } else if (context == "propertyValue") {
          if (!/^#([0-9a-fA-f]{3}|[0-9a-fA-f]{6})$/.test(stream.current())) {
            style += " error";
          }
        } else {
          style = "error";
        }
      } else if (context == "@media" && type == "{") {
        style = "error";
      }
      // Push/pop context stack
      if (type == "{") {
        if (context == "@media" || context == "@mediaType") {
          state.stack[state.stack.length-1] = "@media{";
        }
        else {
          var newContext = allowNested ? "block" : "rule";
          state.stack.push(newContext);
        }
      }
      else if (type == "}") {
        if (context == "interpolation") style = "operator";
        // Pop off end of array until { is reached
        while(state.stack.length){
          var removed = state.stack.pop();
          if(removed.indexOf("{") > -1){
            break;
          }
        }
      }
      else if (type == "interpolation") state.stack.push("interpolation");
      else if (type == "@media") state.stack.push("@media");
      else if (type == "@import") state.stack.push("@import");
      else if (context == "@media" && /\b(keyword|attribute)\b/.test(style))
        state.stack[state.stack.length-1] = "@mediaType";
      else if (context == "@mediaType" && stream.current() == ",")
        state.stack[state.stack.length-1] = "@media";
      else if (type == "(") {
        if (context == "@media" || context == "@mediaType") {
          // Make sure @mediaType is used to avoid error on {
          state.stack[state.stack.length-1] = "@mediaType";
          state.stack.push("@mediaType(");
        }
        else state.stack.push("(");
      }
      else if (type == ")") {
        // Pop off end of array until ( is reached
        while(state.stack.length){
          var removed = state.stack.pop();
          if(removed.indexOf("(") > -1){
            break;
          }
        }
      }
      else if (type == ":" && state.lastToken == "property") state.stack.push("propertyValue");
      else if (context == "propertyValue" && type == ";") state.stack.pop();
      else if (context == "@import" && type == ";") state.stack.pop();
      return state.lastToken = style;
    },
    indent: function(state, textAfter) {
      var n = state.stack.length;
      if (/^\}/.test(textAfter))
        n -= state.stack[n-1] == "propertyValue" ? 2 : 1;
      return state.baseIndent + n * indentUnit;
    },
    electricChars: "}",
    blockCommentStart: "/*",
    blockCommentEnd: "*/",
    fold: "brace"
  };
 });
 (function() {
  function keySet(array) {
    var keys = {};
    for (var i = 0; i < array.length; ++i) {
      keys[array[i]] = true;
    }
    return keys;
  }
  var atMediaTypes = keySet([
    "all", "aural", "braille", "handheld", "print", "projection", "screen",
    "tty", "tv", "embossed"
  ]);
  var atMediaFeatures = keySet([
    "width", "min-width", "max-width", "height", "min-height", "max-height",
    "device-width", "min-device-width", "max-device-width", "device-height",
    "min-device-height", "max-device-height", "aspect-ratio",
    "min-aspect-ratio", "max-aspect-ratio", "device-aspect-ratio",
    "min-device-aspect-ratio", "max-device-aspect-ratio", "color", "min-color",
    "max-color", "color-index", "min-color-index", "max-color-index",
    "monochrome", "min-monochrome", "max-monochrome", "resolution",
    "min-resolution", "max-resolution", "scan", "grid"
  ]);
  var propertyKeywords = keySet([
    "align-content", "align-items", "align-self", "alignment-adjust",
    "alignment-baseline", "anchor-point", "animation", "animation-delay",
    "animation-direction", "animation-duration", "animation-iteration-count",
    "animation-name", "animation-play-state", "animation-timing-function",
    "appearance", "azimuth", "backface-visibility", "background",
    "background-attachment", "background-clip", "background-color",
    "background-image", "background-origin", "background-position",
    "background-repeat", "background-size", "baseline-shift", "binding",
    "bleed", "bookmark-label", "bookmark-level", "bookmark-state",
    "bookmark-target", "border", "border-bottom", "border-bottom-color",
    "border-bottom-left-radius", "border-bottom-right-radius",
    "border-bottom-style", "border-bottom-width", "border-collapse",
    "border-color", "border-image", "border-image-outset",
    "border-image-repeat", "border-image-slice", "border-image-source",
    "border-image-width", "border-left", "border-left-color",
    "border-left-style", "border-left-width", "border-radius", "border-right",
    "border-right-color", "border-right-style", "border-right-width",
    "border-spacing", "border-style", "border-top", "border-top-color",
    "border-top-left-radius", "border-top-right-radius", "border-top-style",
    "border-top-width", "border-width", "bottom", "box-decoration-break",
    "box-shadow", "box-sizing", "break-after", "break-before", "break-inside",
    "caption-side", "clear", "clip", "color", "color-profile", "column-count",
    "column-fill", "column-gap", "column-rule", "column-rule-color",
    "column-rule-style", "column-rule-width", "column-span", "column-width",
    "columns", "content", "counter-increment", "counter-reset", "crop", "cue",
    "cue-after", "cue-before", "cursor", "direction", "display",
    "dominant-baseline", "drop-initial-after-adjust",
    "drop-initial-after-align", "drop-initial-before-adjust",
    "drop-initial-before-align", "drop-initial-size", "drop-initial-value",
    "elevation", "empty-cells", "fit", "fit-position", "flex", "flex-basis",
    "flex-direction", "flex-flow", "flex-grow", "flex-shrink", "flex-wrap",
    "float", "float-offset", "flow-from", "flow-into", "font", "font-feature-settings",
    "font-family", "font-kerning", "font-language-override", "font-size", "font-size-adjust",
    "font-stretch", "font-style", "font-synthesis", "font-variant",
    "font-variant-alternates", "font-variant-caps", "font-variant-east-asian",
    "font-variant-ligatures", "font-variant-numeric", "font-variant-position",
    "font-weight", "grid-cell", "grid-column", "grid-column-align",
    "grid-column-sizing", "grid-column-span", "grid-columns", "grid-flow",
    "grid-row", "grid-row-align", "grid-row-sizing", "grid-row-span",
    "grid-rows", "grid-template", "hanging-punctuation", "height", "hyphens",
    "icon", "image-orientation", "image-rendering", "image-resolution",
    "inline-box-align", "justify-content", "left", "letter-spacing",
    "line-break", "line-height", "line-stacking", "line-stacking-ruby",
    "line-stacking-shift", "line-stacking-strategy", "list-style",
    "list-style-image", "list-style-position", "list-style-type", "margin",
    "margin-bottom", "margin-left", "margin-right", "margin-top",
    "marker-offset", "marks", "marquee-direction", "marquee-loop",
    "marquee-play-count", "marquee-speed", "marquee-style", "max-height",
    "max-width", "min-height", "min-width", "move-to", "nav-down", "nav-index",
    "nav-left", "nav-right", "nav-up", "opacity", "order", "orphans", "outline",
    "outline-color", "outline-offset", "outline-style", "outline-width",
    "overflow", "overflow-style", "overflow-wrap", "overflow-x", "overflow-y",
    "padding", "padding-bottom", "padding-left", "padding-right", "padding-top",
    "page", "page-break-after", "page-break-before", "page-break-inside",
    "page-policy", "pause", "pause-after", "pause-before", "perspective",
    "perspective-origin", "pitch", "pitch-range", "play-during", "position",
    "presentation-level", "punctuation-trim", "quotes", "region-break-after",
    "region-break-before", "region-break-inside", "region-fragment",
    "rendering-intent", "resize", "rest", "rest-after", "rest-before", "richness",
    "right", "rotation", "rotation-point", "ruby-align", "ruby-overhang",
    "ruby-position", "ruby-span", "shape-inside", "shape-outside", "size",
    "speak", "speak-as", "speak-header",
    "speak-numeral", "speak-punctuation", "speech-rate", "stress", "string-set",
    "tab-size", "table-layout", "target", "target-name", "target-new",
    "target-position", "text-align", "text-align-last", "text-decoration",
    "text-decoration-color", "text-decoration-line", "text-decoration-skip",
    "text-decoration-style", "text-emphasis", "text-emphasis-color",
    "text-emphasis-position", "text-emphasis-style", "text-height",
    "text-indent", "text-justify", "text-outline", "text-overflow", "text-shadow",
    "text-size-adjust", "text-space-collapse", "text-transform", "text-underline-position",
    "text-wrap", "top", "transform", "transform-origin", "transform-style",
    "transition", "transition-delay", "transition-duration",
    "transition-property", "transition-timing-function", "unicode-bidi",
    "vertical-align", "visibility", "voice-balance", "voice-duration",
    "voice-family", "voice-pitch", "voice-range", "voice-rate", "voice-stress",
    "voice-volume", "volume", "white-space", "widows", "width", "word-break",
    "word-spacing", "word-wrap", "z-index", "zoom",
    // SVG-specific
    "clip-path", "clip-rule", "mask", "enable-background", "filter", "flood-color",
    "flood-opacity", "lighting-color", "stop-color", "stop-opacity", "pointer-events",
    "color-interpolation", "color-interpolation-filters", "color-profile",
    "color-rendering", "fill", "fill-opacity", "fill-rule", "image-rendering",
    "marker", "marker-end", "marker-mid", "marker-start", "shape-rendering", "stroke",
    "stroke-dasharray", "stroke-dashoffset", "stroke-linecap", "stroke-linejoin",
    "stroke-miterlimit", "stroke-opacity", "stroke-width", "text-rendering",
    "baseline-shift", "dominant-baseline", "glyph-orientation-horizontal",
    "glyph-orientation-vertical", "kerning", "text-anchor", "writing-mode"
  ]);
  var colorKeywords = keySet([
    "aliceblue", "antiquewhite", "aqua", "aquamarine", "azure", "beige",
    "bisque", "black", "blanchedalmond", "blue", "blueviolet", "brown",
    "burlywood", "cadetblue", "chartreuse", "chocolate", "coral", "cornflowerblue",
    "cornsilk", "crimson", "cyan", "darkblue", "darkcyan", "darkgoldenrod",
    "darkgray", "darkgreen", "darkkhaki", "darkmagenta", "darkolivegreen",
    "darkorange", "darkorchid", "darkred", "darksalmon", "darkseagreen",
    "darkslateblue", "darkslategray", "darkturquoise", "darkviolet",
    "deeppink", "deepskyblue", "dimgray", "dodgerblue", "firebrick",
    "floralwhite", "forestgreen", "fuchsia", "gainsboro", "ghostwhite",
    "gold", "goldenrod", "gray", "grey", "green", "greenyellow", "honeydew",
    "hotpink", "indianred", "indigo", "ivory", "khaki", "lavender",
    "lavenderblush", "lawngreen", "lemonchiffon", "lightblue", "lightcoral",
    "lightcyan", "lightgoldenrodyellow", "lightgray", "lightgreen", "lightpink",
    "lightsalmon", "lightseagreen", "lightskyblue", "lightslategray",
    "lightsteelblue", "lightyellow", "lime", "limegreen", "linen", "magenta",
    "maroon", "mediumaquamarine", "mediumblue", "mediumorchid", "mediumpurple",
    "mediumseagreen", "mediumslateblue", "mediumspringgreen", "mediumturquoise",
    "mediumvioletred", "midnightblue", "mintcream", "mistyrose", "moccasin",
    "navajowhite", "navy", "oldlace", "olive", "olivedrab", "orange", "orangered",
    "orchid", "palegoldenrod", "palegreen", "paleturquoise", "palevioletred",
    "papayawhip", "peachpuff", "peru", "pink", "plum", "powderblue",
    "purple", "red", "rosybrown", "royalblue", "saddlebrown", "salmon",
    "sandybrown", "seagreen", "seashell", "sienna", "silver", "skyblue",
    "slateblue", "slategray", "snow", "springgreen", "steelblue", "tan",
    "teal", "thistle", "tomato", "turquoise", "violet", "wheat", "white",
    "whitesmoke", "yellow", "yellowgreen"
  ]);
  var valueKeywords = keySet([
    "above", "absolute", "activeborder", "activecaption", "afar",
    "after-white-space", "ahead", "alias", "all", "all-scroll", "alternate",
    "always", "amharic", "amharic-abegede", "antialiased", "appworkspace",
    "arabic-indic", "armenian", "asterisks", "auto", "avoid", "avoid-column", "avoid-page",
    "avoid-region", "background", "backwards", "baseline", "below", "bidi-override", "binary",
    "bengali", "blink", "block", "block-axis", "bold", "bolder", "border", "border-box",
    "both", "bottom", "break", "break-all", "break-word", "button", "button-bevel",
    "buttonface", "buttonhighlight", "buttonshadow", "buttontext", "cambodian",
    "capitalize", "caps-lock-indicator", "caption", "captiontext", "caret",
    "cell", "center", "checkbox", "circle", "cjk-earthly-branch",
    "cjk-heavenly-stem", "cjk-ideographic", "clear", "clip", "close-quote",
    "col-resize", "collapse", "column", "compact", "condensed", "contain", "content",
    "content-box", "context-menu", "continuous", "copy", "cover", "crop",
    "cross", "crosshair", "currentcolor", "cursive", "dashed", "decimal",
    "decimal-leading-zero", "default", "default-button", "destination-atop",
    "destination-in", "destination-out", "destination-over", "devanagari",
    "disc", "discard", "document", "dot-dash", "dot-dot-dash", "dotted",
    "double", "down", "e-resize", "ease", "ease-in", "ease-in-out", "ease-out",
    "element", "ellipse", "ellipsis", "embed", "end", "ethiopic", "ethiopic-abegede",
    "ethiopic-abegede-am-et", "ethiopic-abegede-gez", "ethiopic-abegede-ti-er",
    "ethiopic-abegede-ti-et", "ethiopic-halehame-aa-er",
    "ethiopic-halehame-aa-et", "ethiopic-halehame-am-et",
    "ethiopic-halehame-gez", "ethiopic-halehame-om-et",
    "ethiopic-halehame-sid-et", "ethiopic-halehame-so-et",
    "ethiopic-halehame-ti-er", "ethiopic-halehame-ti-et",
    "ethiopic-halehame-tig", "ew-resize", "expanded", "extra-condensed",
    "extra-expanded", "fantasy", "fast", "fill", "fixed", "flat", "footnotes",
    "forwards", "from", "geometricPrecision", "georgian", "graytext", "groove",
    "gujarati", "gurmukhi", "hand", "hangul", "hangul-consonant", "hebrew",
    "help", "hidden", "hide", "higher", "highlight", "highlighttext",
    "hiragana", "hiragana-iroha", "horizontal", "hsl", "hsla", "icon", "ignore",
    "inactiveborder", "inactivecaption", "inactivecaptiontext", "infinite",
    "infobackground", "infotext", "inherit", "initial", "inline", "inline-axis",
    "inline-block", "inline-table", "inset", "inside", "intrinsic", "invert",
    "italic", "justify", "kannada", "katakana", "katakana-iroha", "keep-all", "khmer",
    "landscape", "lao", "large", "larger", "left", "level", "lighter",
    "line-through", "linear", "lines", "list-item", "listbox", "listitem",
    "local", "logical", "loud", "lower", "lower-alpha", "lower-armenian",
    "lower-greek", "lower-hexadecimal", "lower-latin", "lower-norwegian",
    "lower-roman", "lowercase", "ltr", "malayalam", "match",
    "media-controls-background", "media-current-time-display",
    "media-fullscreen-button", "media-mute-button", "media-play-button",
    "media-return-to-realtime-button", "media-rewind-button",
    "media-seek-back-button", "media-seek-forward-button", "media-slider",
    "media-sliderthumb", "media-time-remaining-display", "media-volume-slider",
    "media-volume-slider-container", "media-volume-sliderthumb", "medium",
    "menu", "menulist", "menulist-button", "menulist-text",
    "menulist-textfield", "menutext", "message-box", "middle", "min-intrinsic",
    "mix", "mongolian", "monospace", "move", "multiple", "myanmar", "n-resize",
    "narrower", "ne-resize", "nesw-resize", "no-close-quote", "no-drop",
    "no-open-quote", "no-repeat", "none", "normal", "not-allowed", "nowrap",
    "ns-resize", "nw-resize", "nwse-resize", "oblique", "octal", "open-quote",
    "optimizeLegibility", "optimizeSpeed", "oriya", "oromo", "outset",
    "outside", "outside-shape", "overlay", "overline", "padding", "padding-box",
    "painted", "page", "paused", "persian", "plus-darker", "plus-lighter", "pointer",
    "polygon", "portrait", "pre", "pre-line", "pre-wrap", "preserve-3d", "progress", "push-button",
    "radio", "read-only", "read-write", "read-write-plaintext-only", "rectangle", "region",
    "relative", "repeat", "repeat-x", "repeat-y", "reset", "reverse", "rgb", "rgba",
    "ridge", "right", "round", "row-resize", "rtl", "run-in", "running",
    "s-resize", "sans-serif", "scroll", "scrollbar", "se-resize", "searchfield",
    "searchfield-cancel-button", "searchfield-decoration",
    "searchfield-results-button", "searchfield-results-decoration",
    "semi-condensed", "semi-expanded", "separate", "serif", "show", "sidama",
    "single", "skip-white-space", "slide", "slider-horizontal",
    "slider-vertical", "sliderthumb-horizontal", "sliderthumb-vertical", "slow",
    "small", "small-caps", "small-caption", "smaller", "solid", "somali",
    "source-atop", "source-in", "source-out", "source-over", "space", "square",
    "square-button", "start", "static", "status-bar", "stretch", "stroke",
    "sub", "subpixel-antialiased", "super", "sw-resize", "table",
    "table-caption", "table-cell", "table-column", "table-column-group",
    "table-footer-group", "table-header-group", "table-row", "table-row-group",
    "telugu", "text", "text-bottom", "text-top", "textarea", "textfield", "thai",
    "thick", "thin", "threeddarkshadow", "threedface", "threedhighlight",
    "threedlightshadow", "threedshadow", "tibetan", "tigre", "tigrinya-er",
    "tigrinya-er-abegede", "tigrinya-et", "tigrinya-et-abegede", "to", "top",
    "transparent", "ultra-condensed", "ultra-expanded", "underline", "up",
    "upper-alpha", "upper-armenian", "upper-greek", "upper-hexadecimal",
    "upper-latin", "upper-norwegian", "upper-roman", "uppercase", "urdu", "url",
    "vertical", "vertical-text", "visible", "visibleFill", "visiblePainted",
    "visibleStroke", "visual", "w-resize", "wait", "wave", "wider",
    "window", "windowframe", "windowtext", "x-large", "x-small", "xor",
    "xx-large", "xx-small"
  ]);
  function tokenCComment(stream, state) {
    var maybeEnd = false, ch;
    while ((ch = stream.next()) != null) {
      if (maybeEnd && ch == "/") {
        state.tokenize = null;
        break;
      }
      maybeEnd = (ch == "*");
    }
    return ["comment", "comment"];
  }
  CodeMirror.defineMIME("text/css", {
    atMediaTypes: atMediaTypes,
    atMediaFeatures: atMediaFeatures,
    propertyKeywords: propertyKeywords,
    colorKeywords: colorKeywords,
    valueKeywords: valueKeywords,
    hooks: {
      "<": function(stream, state) {
        function tokenSGMLComment(stream, state) {
          var dashes = 0, ch;
          while ((ch = stream.next()) != null) {
            if (dashes >= 2 && ch == ">") {
              state.tokenize = null;
              break;
            }
            dashes = (ch == "-") ? dashes + 1 : 0;
          }
          return ["comment", "comment"];
        }
        if (stream.eat("!")) {
          state.tokenize = tokenSGMLComment;
          return tokenSGMLComment(stream, state);
        }
      },
      "/": function(stream, state) {
        if (stream.eat("*")) {
          state.tokenize = tokenCComment;
          return tokenCComment(stream, state);
        }
        return false;
      }
    },
    name: "css"
  });
  CodeMirror.defineMIME("text/x-scss", {
    atMediaTypes: atMediaTypes,
    atMediaFeatures: atMediaFeatures,
    propertyKeywords: propertyKeywords,
    colorKeywords: colorKeywords,
    valueKeywords: valueKeywords,
    allowNested: true,
    hooks: {
      ":": function(stream) {
        if (stream.match(/\s*{/)) {
          return [null, "{"];
        }
        return false;
      },
      "$": function(stream) {
        stream.match(/^[\w-]+/);
        if (stream.peek() == ":") {
          return ["variable", "variable-definition"];
        }
        return ["variable", "variable"];
      },
      ",": function(_stream, state) {
        if (state.stack[state.stack.length - 1] == "propertyValue") {
          return ["operator", ";"];
        }
      },
      "/": function(stream, state) {
        if (stream.eat("/")) {
          stream.skipToEnd();
          return ["comment", "comment"];
        } else if (stream.eat("*")) {
          state.tokenize = tokenCComment;
          return tokenCComment(stream, state);
        } else {
          return ["operator", "operator"];
        }
      },
      "#": function(stream) {
        if (stream.eat("{")) {
          return ["operator", "interpolation"];
        } else {
          stream.eatWhile(/[\w\\\-]/);
          return ["atom", "hash"];
        }
      }
    },
    name: "css"
  });
 })();
--- a/examples/vendor/dat.gui.min.js
+++ b/examples/vendor/dat.gui.min.js
--- a/examples/vendor/leaflet.css
+++ b/examples/vendor/leaflet.css
@ -0,0 +1,478 @@
 /* required styles */
 .leaflet-map-pane,
 .leaflet-tile,
 .leaflet-marker-icon,
 .leaflet-marker-shadow,
 .leaflet-tile-pane,
 .leaflet-tile-container,
 .leaflet-overlay-pane,
 .leaflet-shadow-pane,
 .leaflet-marker-pane,
 .leaflet-popup-pane,
 .leaflet-overlay-pane svg,
 .leaflet-zoom-box,
 .leaflet-image-layer,
 .leaflet-layer {
 	position: absolute;
 	left: 0;
 	top: 0;
 	}
 .leaflet-container {
 	overflow: hidden;
 	-ms-touch-action: none;
 	}
 .leaflet-tile,
 .leaflet-marker-icon,
 .leaflet-marker-shadow {
 	-webkit-user-select: none;
 	   -moz-user-select: none;
 	        user-select: none;
 	-webkit-user-drag: none;
 	}
 .leaflet-marker-icon,
 .leaflet-marker-shadow {
 	display: block;
 	}
 /* map is broken in FF if you have max-width: 100% on tiles */
 .leaflet-container img {
 	max-width: none !important;
 	}
 /* stupid Android 2 doesn't understand "max-width: none" properly */
 .leaflet-container img.leaflet-image-layer {
 	max-width: 15000px !important;
 	}
 .leaflet-tile {
 	filter: inherit;
 	visibility: hidden;
 	}
 .leaflet-tile-loaded {
 	visibility: inherit;
 	}
 .leaflet-zoom-box {
 	width: 0;
 	height: 0;
 	}
 /* workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=888319 */
 .leaflet-overlay-pane svg {
 	-moz-user-select: none;
 	}
 .leaflet-tile-pane    { z-index: 2; }
 .leaflet-objects-pane { z-index: 3; }
 .leaflet-overlay-pane { z-index: 4; }
 .leaflet-shadow-pane  { z-index: 5; }
 .leaflet-marker-pane  { z-index: 6; }
 .leaflet-popup-pane   { z-index: 7; }
 .leaflet-vml-shape {
 	width: 1px;
 	height: 1px;
 	}
 .lvml {
 	behavior: url(#default#VML);
 	display: inline-block;
 	position: absolute;
 	}
 /* control positioning */
 .leaflet-control {
 	position: relative;
 	z-index: 7;
 	pointer-events: auto;
 	}
 .leaflet-top,
 .leaflet-bottom {
 	position: absolute;
 	z-index: 1000;
 	pointer-events: none;
 	}
 .leaflet-top {
 	top: 0;
 	}
 .leaflet-right {
 	right: 0;
 	}
 .leaflet-bottom {
 	bottom: 0;
 	}
 .leaflet-left {
 	left: 0;
 	}
 .leaflet-control {
 	float: left;
 	clear: both;
 	}
 .leaflet-right .leaflet-control {
 	float: right;
 	}
 .leaflet-top .leaflet-control {
 	margin-top: 10px;
 	}
 .leaflet-bottom .leaflet-control {
 	margin-bottom: 10px;
 	}
 .leaflet-left .leaflet-control {
 	margin-left: 10px;
 	}
 .leaflet-right .leaflet-control {
 	margin-right: 10px;
 	}
 /* zoom and fade animations */
 .leaflet-fade-anim .leaflet-tile,
 .leaflet-fade-anim .leaflet-popup {
 	opacity: 0;
 	-webkit-transition: opacity 0.2s linear;
 	   -moz-transition: opacity 0.2s linear;
 	     -o-transition: opacity 0.2s linear;
 	        transition: opacity 0.2s linear;
 	}
 .leaflet-fade-anim .leaflet-tile-loaded,
 .leaflet-fade-anim .leaflet-map-pane .leaflet-popup {
 	opacity: 1;
 	}
 .leaflet-zoom-anim .leaflet-zoom-animated {
 	-webkit-transition: -webkit-transform 0.25s cubic-bezier(0,0,0.25,1);
 	   -moz-transition:    -moz-transform 0.25s cubic-bezier(0,0,0.25,1);
 	     -o-transition:      -o-transform 0.25s cubic-bezier(0,0,0.25,1);
 	        transition:         transform 0.25s cubic-bezier(0,0,0.25,1);
 	}
 .leaflet-zoom-anim .leaflet-tile,
 .leaflet-pan-anim .leaflet-tile,
 .leaflet-touching .leaflet-zoom-animated {
 	-webkit-transition: none;
 	   -moz-transition: none;
 	     -o-transition: none;
 	        transition: none;
 	}
 .leaflet-zoom-anim .leaflet-zoom-hide {
 	visibility: hidden;
 	}
 /* cursors */
 .leaflet-clickable {
 	cursor: pointer;
 	}
 .leaflet-container {
 	cursor: -webkit-grab;
 	cursor:    -moz-grab;
 	}
 .leaflet-popup-pane,
 .leaflet-control {
 	cursor: auto;
 	}
 .leaflet-dragging .leaflet-container,
 .leaflet-dragging .leaflet-clickable {
 	cursor: move;
 	cursor: -webkit-grabbing;
 	cursor:    -moz-grabbing;
 	}
 /* visual tweaks */
 .leaflet-container {
 	background: #ddd;
 	outline: 0;
 	}
 .leaflet-container a {
 	color: #0078A8;
 	}
 .leaflet-container a.leaflet-active {
 	outline: 2px solid orange;
 	}
 .leaflet-zoom-box {
 	border: 2px dotted #38f;
 	background: rgba(255,255,255,0.5);
 	}
 /* general typography */
 .leaflet-container {
 	font: 12px/1.5 "Helvetica Neue", Arial, Helvetica, sans-serif;
 	}
 /* general toolbar styles */
 .leaflet-bar {
 	box-shadow: 0 1px 5px rgba(0,0,0,0.65);
 	border-radius: 4px;
 	}
 .leaflet-bar a,
 .leaflet-bar a:hover {
 	background-color: #fff;
 	border-bottom: 1px solid #ccc;
 	width: 26px;
 	height: 26px;
 	line-height: 26px;
 	display: block;
 	text-align: center;
 	text-decoration: none;
 	color: black;
 	}
 .leaflet-bar a,
 .leaflet-control-layers-toggle {
 	background-position: 50% 50%;
 	background-repeat: no-repeat;
 	display: block;
 	}
 .leaflet-bar a:hover {
 	background-color: #f4f4f4;
 	}
 .leaflet-bar a:first-child {
 	border-top-left-radius: 4px;
 	border-top-right-radius: 4px;
 	}
 .leaflet-bar a:last-child {
 	border-bottom-left-radius: 4px;
 	border-bottom-right-radius: 4px;
 	border-bottom: none;
 	}
 .leaflet-bar a.leaflet-disabled {
 	cursor: default;
 	background-color: #f4f4f4;
 	color: #bbb;
 	}
 .leaflet-touch .leaflet-bar a {
 	width: 30px;
 	height: 30px;
 	line-height: 30px;
 	}
 /* zoom control */
 .leaflet-control-zoom-in,
 .leaflet-control-zoom-out {
 	font: bold 18px 'Lucida Console', Monaco, monospace;
 	text-indent: 1px;
 	}
 .leaflet-control-zoom-out {
 	font-size: 20px;
 	}
 .leaflet-touch .leaflet-control-zoom-in {
 	font-size: 22px;
 	}
 .leaflet-touch .leaflet-control-zoom-out {
 	font-size: 24px;
 	}
 /* layers control */
 .leaflet-control-layers {
 	box-shadow: 0 1px 5px rgba(0,0,0,0.4);
 	background: #fff;
 	border-radius: 5px;
 	}
 .leaflet-control-layers-toggle {
 	background-image: url(images/layers.png);
 	width: 36px;
 	height: 36px;
 	}
 .leaflet-retina .leaflet-control-layers-toggle {
 	background-image: url(images/layers-2x.png);
 	background-size: 26px 26px;
 	}
 .leaflet-touch .leaflet-control-layers-toggle {
 	width: 44px;
 	height: 44px;
 	}
 .leaflet-control-layers .leaflet-control-layers-list,
 .leaflet-control-layers-expanded .leaflet-control-layers-toggle {
 	display: none;
 	}
 .leaflet-control-layers-expanded .leaflet-control-layers-list {
 	display: block;
 	position: relative;
 	}
 .leaflet-control-layers-expanded {
 	padding: 6px 10px 6px 6px;
 	color: #333;
 	background: #fff;
 	}
 .leaflet-control-layers-selector {
 	margin-top: 2px;
 	position: relative;
 	top: 1px;
 	}
 .leaflet-control-layers label {
 	display: block;
 	}
 .leaflet-control-layers-separator {
 	height: 0;
 	border-top: 1px solid #ddd;
 	margin: 5px -10px 5px -6px;
 	}
 /* attribution and scale controls */
 .leaflet-container .leaflet-control-attribution {
 	background: #fff;
 	background: rgba(255, 255, 255, 0.7);
 	margin: 0;
 	}
 .leaflet-control-attribution,
 .leaflet-control-scale-line {
 	padding: 0 5px;
 	color: #333;
 	}
 .leaflet-control-attribution a {
 	text-decoration: none;
 	}
 .leaflet-control-attribution a:hover {
 	text-decoration: underline;
 	}
 .leaflet-container .leaflet-control-attribution,
 .leaflet-container .leaflet-control-scale {
 	font-size: 11px;
 	}
 .leaflet-left .leaflet-control-scale {
 	margin-left: 5px;
 	}
 .leaflet-bottom .leaflet-control-scale {
 	margin-bottom: 5px;
 	}
 .leaflet-control-scale-line {
 	border: 2px solid #777;
 	border-top: none;
 	line-height: 1.1;
 	padding: 2px 5px 1px;
 	font-size: 11px;
 	white-space: nowrap;
 	overflow: hidden;
 	-moz-box-sizing: content-box;
 	     box-sizing: content-box;
 	background: #fff;
 	background: rgba(255, 255, 255, 0.5);
 	}
 .leaflet-control-scale-line:not(:first-child) {
 	border-top: 2px solid #777;
 	border-bottom: none;
 	margin-top: -2px;
 	}
 .leaflet-control-scale-line:not(:first-child):not(:last-child) {
 	border-bottom: 2px solid #777;
 	}
 .leaflet-touch .leaflet-control-attribution,
 .leaflet-touch .leaflet-control-layers,
 .leaflet-touch .leaflet-bar {
 	box-shadow: none;
 	}
 .leaflet-touch .leaflet-control-layers,
 .leaflet-touch .leaflet-bar {
 	border: 2px solid rgba(0,0,0,0.2);
 	background-clip: padding-box;
 	}
 /* popup */
 .leaflet-popup {
 	position: absolute;
 	text-align: center;
 	}
 .leaflet-popup-content-wrapper {
 	padding: 1px;
 	text-align: left;
 	border-radius: 12px;
 	}
 .leaflet-popup-content {
 	margin: 13px 19px;
 	line-height: 1.4;
 	}
 .leaflet-popup-content p {
 	margin: 18px 0;
 	}
 .leaflet-popup-tip-container {
 	margin: 0 auto;
 	width: 40px;
 	height: 20px;
 	position: relative;
 	overflow: hidden;
 	}
 .leaflet-popup-tip {
 	width: 17px;
 	height: 17px;
 	padding: 1px;
 	margin: -10px auto 0;
 	-webkit-transform: rotate(45deg);
 	   -moz-transform: rotate(45deg);
 	    -ms-transform: rotate(45deg);
 	     -o-transform: rotate(45deg);
 	        transform: rotate(45deg);
 	}
 .leaflet-popup-content-wrapper,
 .leaflet-popup-tip {
 	background: white;
 	box-shadow: 0 3px 14px rgba(0,0,0,0.4);
 	}
 .leaflet-container a.leaflet-popup-close-button {
 	position: absolute;
 	top: 0;
 	right: 0;
 	padding: 4px 4px 0 0;
 	text-align: center;
 	width: 18px;
 	height: 14px;
 	font: 16px/14px Tahoma, Verdana, sans-serif;
 	color: #c3c3c3;
 	text-decoration: none;
 	font-weight: bold;
 	background: transparent;
 	}
 .leaflet-container a.leaflet-popup-close-button:hover {
 	color: #999;
 	}
 .leaflet-popup-scrolled {
 	overflow: auto;
 	border-bottom: 1px solid #ddd;
 	border-top: 1px solid #ddd;
 	}
 .leaflet-oldie .leaflet-popup-content-wrapper {
 	zoom: 1;
 	}
 .leaflet-oldie .leaflet-popup-tip {
 	width: 24px;
 	margin: 0 auto;
 	-ms-filter: "progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678)";
 	filter: progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678);
 	}
 .leaflet-oldie .leaflet-popup-tip-container {
 	margin-top: -1px;
 	}
 .leaflet-oldie .leaflet-control-zoom,
 .leaflet-oldie .leaflet-control-layers,
 .leaflet-oldie .leaflet-popup-content-wrapper,
 .leaflet-oldie .leaflet-popup-tip {
 	border: 1px solid #999;
 	}
 /* div icon */
 .leaflet-div-icon {
 	background: #fff;
 	border: 1px solid #666;
 	}
--- a/examples/vendor/leaflet.js
+++ b/examples/vendor/leaflet.js
--- a/lib/header.js
+++ b/lib/header.js
@ -15,14 +15,9 @@ headerString = headerString.replace("{{version}}", packageJSON.version)
 ['torque.uncompressed.js'].forEach(function(v){
 	fs.readFile('dist/' + v, 'utf8', function(err, torque) {
-		if (err) {
+		if(!err){	
-			return console.error(err);
+			var torqueString = headerString.replace("{{lib}}", torque);
 			fs.writeFile('dist/' + v, torqueString); 
 		}
 		var torqueString = headerString.replace("{{lib}}", torque);
 		fs.writeFile('dist/' + v, torqueString, function (err) {
 			if (err) {
 				return console.error(err);
 			}
 		});
 	});
 });
--- a/lib/torque/gmaps/torque.js
+++ b/lib/torque/gmaps/torque.js
@ -34,8 +34,6 @@ function GMapsTorqueLayer(options) {
  this.hidden = !this.options.visible;
  this.showLimitErrors = options.showLimitErrors;
  this.animator = new torque.Animator(function(time) {
    var k = time | 0;
    if(self.getKey() !== k) {
@ -65,6 +63,8 @@ function GMapsTorqueLayer(options) {
  CanvasLayer.call(this, {
    map: this.options.map,
    //resizeHandler: this.redraw,
    animate: false,
    updateHandler: this.render,
    readyHandler: this.initialize
@ -115,11 +115,11 @@ GMapsTorqueLayer.prototype = torque.extend({},
    this.renderer.options.errorCallback = this.options.errorCallback;
    // this listener should be before tile loader
-    this._cacheListener = google.maps.event.addListener(this.map, 'zoom_changed', function() {
+    this._cacheListener = google.maps.event.addListener(this.options.map, 'zoom_changed', function() {
      self.renderer && self.renderer.clearSpriteCache();
    });
-    this._initTileLoader(this.map, this.getProjection());
+    this._initTileLoader(this.options.map, this.getProjection());
    if (this.shader) {
      this.renderer.setShader(this.shader);
@ -182,24 +182,15 @@ GMapsTorqueLayer.prototype = torque.extend({},
    // for each tile shown on the map request the data
  onTileAdded: function(t) {
    var self = this;
-    var callback = function (tileData, error) {
+    this.provider.getTileData(t, t.zoom, function(tileData) {
      // don't load tiles that are not being shown
-      if (t.zoom !== self.map.getZoom()) return;
+      if (t.zoom !== self.options.map.getZoom()) return;
      self._tileLoaded(t, tileData);
-
+      self.fire('tileLoaded');
      if (tileData) {
        self.redraw();
      }
-
+    });
      self.fire('tileLoaded');
      if (error) {
        self.fire('tileError', error);
      }
    }
    this.provider.getTileData(t, t.zoom, callback);
  },
  clear: function() {
@ -330,13 +321,7 @@ GMapsTorqueLayer.prototype = torque.extend({},
   * set the cartocss for the current renderer
   */
  setCartoCSS: function(cartocss) {
-    if (!this.renderer) throw new Error('renderer is not valid');
+    if (this.provider && this.provider.options.named_map) throw new Error("CartoCSS style on named maps is read-only");
    if (this.provider && this.provider.options.named_map) {
      console.log('Torque layer: CartoCSS style on named maps is read-only');
      return false;
    }
    var shader = new carto.RendererJS().render(cartocss);
    this.shader = shader;
    if (this.renderer) {
@ -403,21 +388,6 @@ GMapsTorqueLayer.prototype = torque.extend({},
    }
    return null;
  },
  /** return the number of points for a step */
  pointCount: function(step) {
    var t, tile;
    step = step === undefined ? this.key: step;
    var c = 0;
    for(t in this._tiles) {
      tile = this._tiles[t];
      if (tile) {
        c += tile.timeCount[step];
      }
    }
    return c;
  },
  getValueForBBox: function(x, y, w, h) {
    var xf = x + w, yf = y + h;
    var sum = 0;
--- a/lib/torque/index.js
+++ b/lib/torque/index.js
@ -15,5 +15,3 @@ var gmaps = require('./gmaps');
 module.exports.GMapsTileLoader = gmaps.GMapsTileLoader;
 module.exports.GMapsTorqueLayer = gmaps.GMapsTorqueLayer;
 module.exports.GMapsTiledTorqueLayer = gmaps.GMapsTiledTorqueLayer;
 require('./ol');
--- a/lib/torque/leaflet/canvas_layer.js
+++ b/lib/torque/leaflet/canvas_layer.js
@ -4,7 +4,7 @@ require('./leaflet_tileloader_mixin');
 * full canvas layer implementation for Leaflet
 */
-L.CanvasLayer = L.Layer.extend({
+L.CanvasLayer = L.Class.extend({
  includes: [L.Mixin.Events, L.Mixin.TileLoader],
@ -128,13 +128,13 @@ L.CanvasLayer = L.Layer.extend({
    var origin = {
      x:  newCenter.x - oldCenter.x + pos.x,
-      y:  newCenter.y - oldCenter.y + pos.y
+      y:  newCenter.y - oldCenter.y + pos.y,
    };
    var bg = back;
    var transform = L.DomUtil.TRANSFORM;
    setTimeout(function() {
-      bg.style[transform] = 'translate(' + origin.x + 'px, ' + origin.y + 'px) scale(' + e.scale + ') ';
+      bg.style[transform] = L.DomUtil.getTranslateString(origin) + ' scale(' + e.scale + ') ';
    }, 0)
  },
@ -161,7 +161,7 @@ L.CanvasLayer = L.Layer.extend({
    this._container.parentNode.removeChild(this._container);
    map.off({
      'viewreset': this._reset,
-      'move': this.redraw,
+      'move': this._render,
      'moveend': this._reset,
      'resize': this._reset,
      'zoomanim': this._animateZoom,
@ -186,8 +186,6 @@ L.CanvasLayer = L.Layer.extend({
  },
  setZIndex: function(zIndex) {
    zIndex = zIndex !== void 0 ? zIndex : 1;
    this._container.style.zIndex = zIndex;
    this._canvas.style.zIndex = zIndex;
    if (this.options.zoomAnimation) {
      this._backCanvas.style.zIndex = zIndex;
--- a/lib/torque/leaflet/leaflet_tileloader_mixin.js
+++ b/lib/torque/leaflet/leaflet_tileloader_mixin.js
@ -1,6 +1,7 @@
 L.Mixin.TileLoader = {
  _initTileLoader: function() {
    this._tiles = {}
    this._tilesLoading = {};
    this._tilesToLoad = 0;
    this._map.on({
@ -99,7 +100,7 @@ L.Mixin.TileLoader = {
  getTilePos: function (tilePoint) {
    tilePoint = new L.Point(tilePoint.x, tilePoint.y);
-    var origin = this._map._getTopLeftPoint(this._map.getCenter()),
+    var origin = this._map._getNewTopLeftPoint(this._map.getCenter()),
        tileSize = this.options.tileSize;
    return tilePoint.multiplyBy(tileSize).subtract(origin);
@ -110,8 +111,6 @@ L.Mixin.TileLoader = {
          center = bounds.getCenter(),
          zoom = this._map.getZoom();
      zoom = Math.round(zoom);
      var j, i, point;
      for (j = bounds.min.y; j <= bounds.max.y; j++) {
--- a/lib/torque/leaflet/torque.js
+++ b/lib/torque/leaflet/torque.js
@ -27,7 +27,6 @@ L.TorqueLayer = L.CanvasLayer.extend({
    }
    options.tileLoader = true;
    this.keys = [0];
    this._tiles = {};
    Object.defineProperty(this, 'key', {
      get: function() {
        return this.getKey();
@ -35,9 +34,7 @@ L.TorqueLayer = L.CanvasLayer.extend({
    });
    this.prevRenderedKey = 0;
    if (options.cartocss) {
-      // We're only passing the Map header to the global options because the parser won't like turbocarto expressions
+      torque.extend(options, torque.common.TorqueLayer.optionsFromCartoCSS(options.cartocss));
      var headerCartoCSS = options.cartocss.replace(/\n/g,'').match(/Map\s*?\{.*?}/g)[0];
      torque.extend(options, torque.common.TorqueLayer.optionsFromCartoCSS(headerCartoCSS));
    }
    options.resolution = options.resolution || 2;
@ -72,6 +69,7 @@ L.TorqueLayer = L.CanvasLayer.extend({
    this.setDuration = this.animator.duration.bind(this.animator);
    this.isRunning = this.animator.isRunning.bind(this.animator);
    L.CanvasLayer.prototype.initialize.call(this, options);
    this.options.renderer = this.options.renderer || 'point';
@ -79,13 +77,9 @@ L.TorqueLayer = L.CanvasLayer.extend({
    if (this.options.tileJSON) this.options.provider = 'tileJSON';
    this.showLimitErrors = options.showLimitErrors;
    this.provider = new this.providers[this.options.provider](options);
    options.layer = this;
    this.renderer = new this.renderers[this.options.renderer](this.getCanvas(), options);
    options.ready = function() {
      self.fire("change:bounds", {
        bounds: self.provider.getBounds()
@ -98,34 +92,23 @@ L.TorqueLayer = L.CanvasLayer.extend({
      self.setKeys(self.getKeys());
    };
    this.on('tileLoaded', function () {
      self.renderer.setCartoCSS(self.renderer.style);
    })
    this.renderer.on("allIconsLoaded", this.render.bind(this));
    // for each tile shown on the map request the data
    this.on('tileAdded', function(t) {
-      var callback = function (tileData, error) {
+      var tileData = this.provider.getTileData(t, t.zoom, function(tileData) {
        // don't load tiles that are not being shown
        if (t.zoom !== self._map.getZoom()) return;
        self._tileLoaded(t, tileData);
        self._clearTileCaches();
        if (tileData) {
          self.redraw();
        }
        self.fire('tileLoaded');
-
+      });
        if (error) {
          self.fire('tileError', error);
        }
      };
      var tileData = this.provider.getTileData(t, t.zoom, callback);
    }, this);
  },
  _clearTileCaches: function() {
@ -146,7 +129,7 @@ L.TorqueLayer = L.CanvasLayer.extend({
  onAdd: function (map) {
    map.on({
      'zoomend': this._clearCaches,
-      'zoomstart': this._pauseOnZoom
+      'zoomstart': this._pauseOnZoom,
    }, this);
    map.on({
@ -160,7 +143,7 @@ L.TorqueLayer = L.CanvasLayer.extend({
    this._removeTileLoader();
    map.off({
      'zoomend': this._clearCaches,
-      'zoomstart': this._pauseOnZoom
+      'zoomstart': this._pauseOnZoom,
    }, this);
    map.off({
      'zoomend': this._resumeOnZoom
@ -399,32 +382,27 @@ L.TorqueLayer = L.CanvasLayer.extend({
   * set the cartocss for the current renderer
   */
  setCartoCSS: function(cartocss) {
    if (this.provider.options.named_map) throw new Error("CartoCSS style on named maps is read-only");
    if (!this.renderer) throw new Error('renderer is not valid');
    var shader = new carto.RendererJS().render(cartocss);
    this.renderer.setShader(shader);
-    if (this.provider && this.provider.options.named_map) {
+    // provider options
-      console.log('Torque layer: CartoCSS style on named maps is read-only');
+    var options = torque.common.TorqueLayer.optionsFromLayer(shader.findLayer({ name: 'Map' }));
-      return false;
+    this.provider.setCartoCSS && this.provider.setCartoCSS(cartocss);
    if(this.provider.setOptions(options)) {
      this._reloadTiles();
    }
-    this.renderer.setCartoCSS(cartocss, function () {
+    torque.extend(this.options, options);
      // provider options
      var options = torque.common.TorqueLayer.optionsFromLayer(this.renderer._shader.findLayer({ name: 'Map' }));
      this.provider.setCartoCSS && this.provider.setCartoCSS(cartocss);
      if(this.provider.setOptions(options)) {
        this._reloadTiles();
      }
      torque.extend(this.options, options);
      // animator options
      if (options.animationDuration) {
        this.animator.duration(options.animationDuration);
      }
      this._clearCaches();
      this.redraw();
      return this;
    }.bind(this));
    // animator options
    if (options.animationDuration) {
      this.animator.duration(options.animationDuration);
    }
    this._clearCaches();
    this.redraw();
    return this;
  },
  /**
@ -494,20 +472,6 @@ L.TorqueLayer = L.CanvasLayer.extend({
    return sum;
  },
  /** return the number of points for a step */
  pointCount: function(step) {
    var t, tile;
    step = step === undefined ? this.key: step;
    var c = 0;
    for(t in this._tiles) {
      tile = this._tiles[t];
      if (tile) {
        c += tile.timeCount[step];
      }
    }
    return c;
  },
  invalidate: function() {
    this.provider.reload();
  },
@ -522,10 +486,5 @@ L.TorqueLayer = L.CanvasLayer.extend({
  getStepsRange: function() {
    return this.animator.stepsRange();
  },
  onRemove: function(map) {
    L.CanvasLayer.prototype.onRemove.apply(this, arguments);
    this.animator.stop();
  }
 });
--- a/lib/torque/ol/canvas_layer.js
+++ b/lib/torque/ol/canvas_layer.js
@ -1,131 +0,0 @@
 require('./ol_tileloader_mixin');
 ol.CanvasLayer = function(options) {
    this.root_ = document.createElement('div');
    this.root_.setAttribute('class', 'ol-heatmap-layer');
    this.options = {
        subdomains: 'abc',
        errorTileUrl: '',
        attribution: '',
        opacity: 1,
        tileLoader: false, // installs tile loading events
        tileSize: 256
    };
    options = options || {};
    torque.extend(this.options, options);
    ol.TileLoader.call(this, this.options.tileSize, this.options.maxZoom);
    this.render = this.render.bind(this);
    this._canvas = this._createCanvas();
    this.root_.appendChild(this._canvas);
    this._ctx = this._canvas.getContext('2d');
    this.currentAnimationFrame = -1;
    this.requestAnimationFrame = window.requestAnimationFrame || window.mozRequestAnimationFrame ||
    window.webkitRequestAnimationFrame || window.msRequestAnimationFrame || function (callback) {
        return window.setTimeout(callback, 1000 / 60);
    };
    this.cancelAnimationFrame = window.cancelAnimationFrame || window.mozCancelAnimationFrame ||
    window.webkitCancelAnimationFrame || window.msCancelAnimationFrame || function (id) {
        clearTimeout(id);
    };
    if(options.map){
        this.setMap(options.map);
    }
 };
 ol.inherits(ol.CanvasLayer, ol.TileLoader);
 ol.CanvasLayer.prototype.setMap = function(map){
    if(this._map){
        //remove
        this._map.unByKey(this.pointdragKey_);
        this._map.unByKey(this.sizeChangedKey_);
        this._map.unByKey(this.moveendKey_);
        this._map.getView().unByKey(this.centerChanged_);
    }
    this._map = map;
    if(map){
        var overlayContainer  = this._map.getViewport().getElementsByClassName("ol-overlaycontainer")[0];
        overlayContainer.appendChild(this.root_);
        this.pointdragKey_ = map.on('pointerdrag', this._render, this);
        this.moveendKey_ = map.on("moveend", this._render, this);
        this.centerChanged_ = map.getView().on("change:center", this._render, this);
        this.sizeChangedKey_ = map.on('change:size', this._reset, this);
        if(this.options.tileLoader) {
            ol.TileLoader.prototype._initTileLoader.call(this, map);
        }
        this._reset();
    }
 };
 ol.CanvasLayer.prototype._createCanvas = function() {
    var canvas;
    canvas = document.createElement('canvas');
    canvas.style.position = 'absolute';
    canvas.style.top = 0;
    canvas.style.left = 0;
    canvas.style.pointerEvents = "none";
    canvas.style.zIndex = this.options.zIndex || 0;
    return canvas;
 };
 ol.CanvasLayer.prototype._reset = function () {
    this._resize();
 };
 ol.CanvasLayer.prototype._resize =  function() {
    var size = this._map.getSize();
    var width = size[0];
    var height = size[1];
    var oldWidth = this._canvas.width;
    var oldHeight = this._canvas.height;
    // resizing may allocate a new back buffer, so do so conservatively
    if (oldWidth !== width || oldHeight !== height) {
        this._canvas.width = width;
        this._canvas.height = height;
        this._canvas.style.width = width + 'px';
        this._canvas.style.height = height + 'px';
        this.root_.style.width = width + 'px';
        this.root_.style.height = height + 'px';
        this._render();
    }
 };
 ol.CanvasLayer.prototype._render = function() {
    if (this.currentAnimationFrame >= 0) {
        this.cancelAnimationFrame.call(window, this.currentAnimationFrame);
    }
    this.currentAnimationFrame = this.requestAnimationFrame.call(window, this.render);
 };
 ol.CanvasLayer.prototype.getCanvas = function() {
        return this._canvas;
 };
 ol.CanvasLayer.prototype.getAttribution = function() {
        return this.options.attribution;
 };
 ol.CanvasLayer.prototype.draw = function() {
        return this._render();
 };
 ol.CanvasLayer.prototype.redraw = function(direct) {
    if (direct) {
        this.render();
    } else {
        this._render();
    }
 };
 module.exports = ol.CanvasLayer;
--- a/lib/torque/ol/index.js
+++ b/lib/torque/ol/index.js
@ -1,3 +0,0 @@
 if (typeof ol !== 'undefined') {
    require('./torque');
 }
--- a/lib/torque/ol/ol_tileloader_mixin.js
+++ b/lib/torque/ol/ol_tileloader_mixin.js
@ -1,169 +0,0 @@
 ol.TileLoader = function(tileSize, maxZoom){
    this._tileSize = tileSize;
    this._tiles = {};
    this._tilesLoading = {};
    this._tilesToLoad = 0;
    this._updateTiles = this._updateTiles.bind(this);
    this._tileGrid = ol.tilegrid.createXYZ({
        maxZoom: maxZoom,
        tileSize: tileSize
    });
 };
 ol.TileLoader.prototype._initTileLoader = function(map) {
    this._map = map;
    this._view = map.getView();
    this._centerChangedId = this._view.on("change:center", function(e){
        this._updateTiles();
    },  this);
    this._postcomposeKey = undefined;
    this._resolutionChangedId = this._view.on("change:resolution", function(evt){
        this._currentResolution = this._view.getResolution();
        if(this._postcomposeKey) return;
        this.fire("mapZoomStart");
        this._postcomposeKey = this._map.on("postcompose", function(evt) {
            if(evt.frameState.viewState.resolution === this._currentResolution){
                this._updateTiles();
                this._map.unByKey(this._postcomposeKey);
                this._postcomposeKey = undefined;
                this.fire("mapZoomEnd");
            }
        }, this);
    }, this);
    this._updateTiles();
 };
 ol.TileLoader.prototype._removeTileLoader = function() {
    this._view.unByKey(this._centerChangedId);
    this._view.unByKey(this._resolutionChangedId );
    this._removeTiles();
 };
 ol.TileLoader.prototype._removeTiles = function () {
    for (var key in this._tiles) {
        this._removeTile(key);
    }
 };
 ol.TileLoader.prototype._reloadTiles = function() {
    this._removeTiles();
    this._updateTiles();
 };
 ol.TileLoader.prototype._updateTiles = function () {
    if (!this._map) { return; }
    var zoom =  this._tileGrid.getZForResolution(this._view.getResolution());
    var extent = this._view.calculateExtent(this._map.getSize());
    var tileRange = this._requestTilesForExtentAndZ(extent, zoom);
    this._removeOtherTiles(tileRange);
 };
 ol.TileLoader.prototype._removeOtherTiles = function(tileRange) {
    var kArr, x, y, z, key;
    var zoom =  this._tileGrid.getZForResolution(this._view.getResolution());
    for (key in this._tiles) {
        if (this._tiles.hasOwnProperty(key)) {
            kArr = key.split(':');
            x = parseInt(kArr[0], 10);
            y = parseInt(kArr[1], 10);
            z = parseInt(kArr[2], 10);
            // remove tile if it's out of bounds
            if (z !== zoom || x < tileRange.minX || x > tileRange.maxX || ((-y-1) < tileRange.minY) || (-y-1) > tileRange.maxY) {
                this._removeTile(key);
            }
        }
    }
 };
 ol.TileLoader.prototype._removeTile = function (key) {
    this.fire('tileRemoved', this._tiles[key]);
    delete this._tiles[key];
    delete this._tilesLoading[key];
 };
 ol.TileLoader.prototype._tileKey = function(tilePoint) {
    return tilePoint.x + ':' + tilePoint.y + ':' + tilePoint.zoom;
 };
 ol.TileLoader.prototype._tileShouldBeLoaded = function (tilePoint) {
    var k = this._tileKey(tilePoint);
    return !(k in this._tiles)  && !(k in this._tilesLoading);
 };
 ol.TileLoader.prototype._removeFromTilesLoading = function(tilePoint){
    this._tilesToLoad--;
    var k = this._tileKey(tilePoint);
    delete this._tilesLoading[k];
    if(this._tilesToLoad === 0) {
        this.fire("tilesLoaded");
    }
 };
 ol.TileLoader.prototype._tileLoaded = function(tilePoint, tileData) {
    var k = this._tileKey(tilePoint);
    this._tiles[k] = tileData;
 };
 ol.TileLoader.prototype.getTilePos = function (tilePoint) {
    var zoom =  this._tileGrid.getZForResolution(this._view.getResolution());
    var extent = this._tileGrid.getTileCoordExtent([zoom, tilePoint.x, -tilePoint.y-1]);
    var topLeft = this._map.getPixelFromCoordinate([extent[0], extent[3]]);
    return {
        x: topLeft[0],
        y: topLeft[1]
    };
 };
 ol.TileLoader.prototype._requestTilesForExtentAndZ = function (extent, zoom) {
    var queue = [];
    var tileCoords = [];
    this._tileGrid.forEachTileCoord(extent, zoom, function(coord){
        tileCoords.push(coord);
        var point = {
            x: coord[1],
            y: -coord[2] - 1,
            zoom: coord[0]
        };
        if (this._tileShouldBeLoaded(point)) {
            queue.push(point);
        }
    }.bind(this));
    var tilesToLoad = queue.length;
    if (tilesToLoad > 0) {
        this._tilesToLoad += tilesToLoad;
        for (var i = 0; i < tilesToLoad; i++) {
            var t = queue[i];
            var k = this._tileKey(t);
            this._tilesLoading[k] = t;
            // events
            this.fire('tileAdded', t);
        }
        this.fire("tilesLoading");
    }
    var tileRange = {
        minX : tileCoords[0][1],
        maxX : tileCoords [tileCoords.length - 1][1],
        minY : tileCoords[0][2],
        maxY : tileCoords [tileCoords.length - 1] [2]
    };
    return tileRange;
 };
 module.exports = ol.TileLoader;
--- a/lib/torque/ol/torque.js
+++ b/lib/torque/ol/torque.js
@ -1,443 +0,0 @@
 var carto = global.carto || require('carto');
 var torque = require('../');
 require('./canvas_layer');
 ol.TorqueLayer = function(options){
    var self = this;
    if (!torque.isBrowserSupported()) {
        throw new Error("browser is not supported by torque");
    }
    options.tileLoader = true;
    this.keys = [0];
    Object.defineProperty(this, 'key', {
        get: function() {
            return this.getKey();
        }
    });
    this.prevRenderedKey = 0;
    if (options.cartocss) {
        torque.extend(options, torque.common.TorqueLayer.optionsFromCartoCSS(options.cartocss));
    }
    options.resolution = options.resolution || 2;
    options.steps = options.steps || 100;
    options.visible = options.visible === undefined ? true: options.visible;
    this.hidden = !options.visible;
    this.animator = new torque.Animator(function(time) {
        var k = time | 0;
        if(self.getKey() !== k) {
            self.setKey(k, { direct: true });
        }
    }, torque.extend(torque.clone(options), {
        onPause: function() {
            self.fire('pause');
        },
        onStop: function() {
            self.fire('stop');
        },
        onStart: function() {
            self.fire('play');
        },
        onStepsRange: function() {
            self.fire('change:stepsRange', self.animator.stepsRange());
        }
    }));
    this.play = this.animator.start.bind(this.animator);
    this.stop = this.animator.stop.bind(this.animator);
    this.pause = this.animator.pause.bind(this.animator);
    this.toggle = this.animator.toggle.bind(this.animator);
    this.setDuration = this.animator.duration.bind(this.animator);
    this.isRunning = this.animator.isRunning.bind(this.animator);
    ol.CanvasLayer.call(this, options);
    this.options.renderer = this.options.renderer || 'point';
    this.options.provider = this.options.provider || 'windshaft';
    if (this.options.tileJSON) this.options.provider = 'tileJSON';
    this.provider = new this.providers[this.options.provider](options);
    this.renderer = new this.renderers[this.options.renderer](this.getCanvas(), options);
    options.ready = function() {
        self.fire("change:bounds", {
            bounds: self.provider.getBounds()
        });
        self.animator.steps(self.provider.getSteps());
        self.animator.rescale();
        self.fire('change:steps', {
            steps: self.provider.getSteps()
        });
        self.setKeys(self.getKeys());
    };
    this.renderer.on("allIconsLoaded", this.render.bind(this));
    // for each tile shown on the map request the data
    this.on('tileAdded', function(t) {
        var tileData = this.provider.getTileData(t, t.zoom, function(tileData) {
            self._removeFromTilesLoading(t);
            if (t.zoom !== self._tileGrid.getZForResolution(self._view.getResolution())) return;
            self._tileLoaded(t, tileData);
            self.fire('tileLoaded');
            if (tileData) {
                self.redraw();
            }
        });
    }, this);
    this.on('mapZoomStart', function(){
        this.getCanvas().style.display = "none";
        this._pauseOnZoom();
    }, this);
    this.on('mapZoomEnd', function() {
        this.getCanvas().style.display = "block";
        this._resumeOnZoom();
    }, this);
 };
 ol.TorqueLayer.prototype = torque.extend({},
    ol.CanvasLayer.prototype,
    torque.Event,
    {
    providers: {
        'sql_api': torque.providers.json,
        'url_template': torque.providers.JsonArray,
        'windshaft': torque.providers.windshaft,
        'tileJSON': torque.providers.tileJSON
    },
    renderers: {
        'point': torque.renderer.Point,
        'pixel': torque.renderer.Rectangle
    },
    onAdd: function(map){
        ol.CanvasLayer.prototype.setMap.call(this, map);
    },
    onRemove: function(map) {
        this.fire('remove');
        this._removeTileLoader();
    },
    _pauseOnZoom: function() {
        this.wasRunning = this.isRunning();
        if (this.wasRunning) {
            this.pause();
        }
    },
    _resumeOnZoom: function() {
        if (this.wasRunning) {
            this.play();
        }
    },
    hide: function() {
        if(this.hidden) return this;
        this.pause();
        this.clear();
        this.hidden = true;
        return this;
    },
    show: function() {
        if(!this.hidden) return this;
        this.hidden = false;
        this.play();
        if (this.options.steps === 1){
            this.redraw();
        }
        return this;
    },
    setSQL: function(sql) {
        if (this.provider.options.named_map) throw new Error("SQL queries on named maps are read-only");
        if (!this.provider || !this.provider.setSQL) {
            throw new Error("this provider does not support SQL");
        }
        this.provider.setSQL(sql);
        this._reloadTiles();
        return this;
    },
    setBlendMode: function(_) {
        this.renderer.setBlendMode(_);
        this.redraw();
    },
    setSteps: function(steps) {
        this.provider.setSteps(steps);
        this._reloadTiles();
    },
    setColumn: function(column, isTime) {
        this.provider.setColumn(column, isTime);
        this._reloadTiles();
    },
    getTimeBounds: function() {
        return this.provider && this.provider.getKeySpan();
    },
    clear: function() {
        var canvas = this.getCanvas();
        canvas.width = canvas.width;
    },
    /**
     * render the selectef key
     * don't call this function directly, it's called by
     * requestAnimationFrame. Use redraw to refresh it
     */
    render: function() {
        if(this.hidden) return;
        var t, tile, pos;
        var canvas = this.getCanvas();
        this.renderer.clearCanvas();
        var ctx = canvas.getContext('2d');
        // renders only a "frame"
        for(t in this._tiles) {
            tile = this._tiles[t];
            if (tile) {
                pos = this.getTilePos(tile.coord);
                ctx.setTransform(1, 0, 0, 1, pos.x, pos.y);
                this.renderer.renderTile(tile, this.keys);
            }
        }
        this.renderer.applyFilters();
    },
    /**
     * set key to be shown. If it's a single value
     * it renders directly, if it's an array it renders
     * accumulated
     */
    setKey: function(key, options) {
        this.setKeys([key], options);
    },
    /**
     * returns the array of keys being rendered
     */
    getKeys: function() {
        return this.keys;
    },
    setKeys: function(keys, options) {
        this.keys = keys;
        this.animator.step(this.getKey());
        this.redraw(options && options.direct);
        this.fire('change:time', {
            time: this.getTime(),
            step: this.getKey(),
            start: this.getKey(),
            end: this.getLastKey()
        });
    },
    getKey: function() {
        return this.keys[0];
    },
    getLastKey: function() {
        return this.keys[this.keys.length - 1];
    },
    /**
     * helper function, does the same than ``setKey`` but only
     * accepts scalars.
     */
    setStep: function(time) {
        if(time === undefined || time.length !== undefined) {
            throw new Error("setTime only accept scalars");
        }
        this.setKey(time);
    },
    renderRange: function(start, end) {
        this.pause();
        var keys = [];
        for (var i = start; i <= end; i++) {
            keys.push(i);
        }
        this.setKeys(keys);
    },
    resetRenderRange: function() {
        this.stop();
        this.play();
    },
    /**
     * transform from animation step to Date object
     * that contains the animation time
     *
     * ``step`` should be between 0 and ``steps - 1``
     */
    stepToTime: function(step) {
        var times = this.provider.getKeySpan();
        var time = times.start + (times.end - times.start)*(step/this.provider.getSteps());
        return new Date(time);
    },
    timeToStep: function(timestamp) {
        if (typeof timestamp === "Date") timestamp = timestamp.getTime();
        if (!this.provider) return 0;
        var times = this.provider.getKeySpan();
        var step = (this.provider.getSteps() * (timestamp - times.start)) / (times.end - times.start);
        return step;
    },
    getStep: function() {
        return this.getKey();
    },
    /**
     * returns the animation time defined by the data
     * in the defined column. Date object
     */
    getTime: function() {
        return this.stepToTime(this.getKey());
    },
    /**
     * returns an object with the start and end times
     */
    getTimeSpan: function() {
        return this.provider.getKeySpan();
    },
    /**
     * set the cartocss for the current renderer
     */
    setCartoCSS: function(cartocss) {
        if (this.provider.options.named_map) throw new Error("CartoCSS style on named maps is read-only");
        if (!this.renderer) throw new Error('renderer is not valid');
        var shader = new carto.RendererJS().render(cartocss);
        this.renderer.setShader(shader);
        // provider options
        var options = torque.common.TorqueLayer.optionsFromLayer(shader.findLayer({ name: 'Map' }));
        this.provider.setCartoCSS && this.provider.setCartoCSS(cartocss);
        if(this.provider.setOptions(options)) {
            this._reloadTiles();
        }
        torque.extend(this.options, options);
        // animator options
        if (options.animationDuration) {
            this.animator.duration(options.animationDuration);
        }
        this.redraw();
        return this;
    },
    /**
     * get active points for a step in active zoom
     * returns a list of bounding boxes [[] , [], []]
     * empty list if there is no active pixels
     */
    getActivePointsBBox: function(step) {
        var positions = [];
        for(var t in this._tiles) {
            var tile = this._tiles[t];
            positions = positions.concat(this.renderer.getActivePointsBBox(tile, step));
        }
        return positions;
    },
    /**
     * return an array with the values for all the pixels active for the step
     */
    getValues: function(step) {
        var values = [];
        step = step === undefined ? this.getKey(): step;
        var t, tile;
        for(t in this._tiles) {
            tile = this._tiles[t];
            this.renderer.getValues(tile, step, values);
        }
        return values;
    },
    /**
     * return the value for position relative to map coordinates. null for no value
     */
    getValueForPos: function(x, y, step) {
        step = step === undefined ? this.getKey(): step;
        var t, tile, pos, value = null, xx, yy;
        for(t in this._tiles) {
            tile = this._tiles[t];
            pos = this.getTilePos(tile.coord);
            xx = x - pos.x;
            yy = y - pos.y;
            if (xx >= 0 && yy >= 0 && xx < this.renderer.TILE_SIZE && yy <= this.renderer.TILE_SIZE) {
                value = this.renderer.getValueFor(tile, step, xx, yy);
            }
            if (value !== null) {
                return value;
            }
        }
        return null;
    },
    getValueForBBox: function(x, y, w, h) {
        var xf = x + w, yf = y + h, _x=x;
        var sum = 0;
        for(_y = y; _y<yf; _y+=this.options.resolution){
            for(_x = x; _x<xf; _x+=this.options.resolution){
                var thisValue = this.getValueForPos(_x,_y);
                if (thisValue){
                    var bb = thisValue.bbox;
                    var xy = this._map.latLngToContainerPoint([bb[1].lat, bb[1].lon]);
                    if(xy.x < xf && xy.y < yf){
                        sum += thisValue.value;
                    }
                }
            }
        }
        return sum;
    },
    /** return the number of points for a step */
    pointCount: function(step) {
        var t, tile;
        step = step === undefined ? this.key: step;
        var c = 0;
        for(t in this._tiles) {
            tile = this._tiles[t];
            if (tile) {
                c += tile.timeCount[step];
            }
        }
        return c;
    },
    invalidate: function() {
        this.provider.reload();
    },
    setStepsRange: function(start, end) {
        this.animator.stepsRange(start, end);
    },
    removeStepsRange: function() {
        this.animator.removeCustomStepsRange();
    },
    getStepsRange: function() {
        return this.animator.stepsRange();
    }
 });
 module.exports = ol.TorqueLayer;
--- a/lib/torque/provider/windshaft.js
+++ b/lib/torque/provider/windshaft.js
@ -186,17 +186,6 @@
      };
    },
    proccessTileError: function(error, coord, zoom) {
      return {
        error: error,
        coord: {
          x: coord.x,
          y: coord.y,
          z: zoom
        }
      };
    },
    /*setCartoCSS: function(c) {
      this.options.cartocss = c;
    },*/
@ -306,18 +295,11 @@
                .replace('{s}', subdomains[index])
      var extra = this._extraParams();
-      torque.net.get( url + (extra ? "?" + extra: ''), function (response) {
+      torque.net.get( url + (extra ? "?" + extra: ''), function (data) {
        prof_fetch_time.end();
-        if (response && response.responseText) {
+        if (data && data.responseText) {
-          var body = JSON.parse(response.responseText);
+          var rows = JSON.parse(data.responseText);
-
+          callback(self.proccessTile(rows, coord, zoom));
          if (response.status === 429) {
            var error = body.errors_with_context[0];
            callback(self.proccessTileError(error, coord, zoom), error);
          } else {
            callback(self.proccessTile(body, coord, zoom));
          }
        } else {
          Profiler.metric('torque.provider.windshaft.tile.error').inc();
          callback(null);
--- a/lib/torque/renderer/datasource.js
+++ b/lib/torque/renderer/datasource.js
@ -1,52 +0,0 @@
 var d3 = require('d3');
 var jenks = require('turf-jenks');
 function TorqueDataSource (tiles) {
  this.tiles = tiles
 }
 module.exports = TorqueDataSource
 TorqueDataSource.prototype.getName = function () {
  return 'TorqueDataSource'
 }
 TorqueDataSource.prototype.getRamp = function (column, bins, method, callback) {
  var ramp = []
  var error = null
  var values = Object.keys(this.tiles).map(function (t) {
    return this.tiles[t].renderData;
  }.bind(this)).reduce(function (p,c,i) {
    for(var i = 0; i<c.length; i++) {
      p.push(c[i]);
    }
    return p;
  },[]);
  var extent = d3.extent(values);
  if (!method || method === 'equal' || method === 'jenks') {
    var scale = d3.scale.linear().domain([0, bins]).range(extent)
    ramp = d3.range(bins).map(scale)
  } else if (method === 'quantiles') {
    ramp = d3.scale.quantile().range(d3.range(bins)).domain(values).quantiles()
  } else if (method === 'headstails') {
    var sortedValues = values.sort(function(a, b) {
      return a - b;
    });
    if (sortedValues.length < bins) {
      error = 'Number of bins should be lower than total number of rows'
    } else if (sortedValues.length === bins) {
      ramp = sortedValues;
    } else {
      var mean = d3.mean(sortedValues);
      ramp.push(mean);
      for (var i = 1; i < bins; i++) {
        ramp.push(d3.mean(sortedValues.filter(function (v) {
          return v > ramp[length - 1];
        })));
      }
    }
  } else {
    error = new Error('Quantification method ' + method + ' is not supported')
  }
  callback(error, ramp)
 }
--- a/lib/torque/renderer/point.js
+++ b/lib/torque/renderer/point.js
@ -3,11 +3,8 @@ var cartocss = require('./cartocss_render');
 var Profiler = require('../profiler');
 var carto = global.carto || require('carto');
 var Filters = require('./torque_filters');
 var turbocarto = require('turbo-carto');
 var CartoDatasource = require('./datasource');
  var ERROR_IMG_URL = 'http://s3.amazonaws.com/com.cartodb.assets.static/error.svg';
  var TAU = Math.PI * 2;
  var DEFAULT_CARTOCSS = [
    '#layer {',
    '  marker-fill: #662506;',
@ -23,46 +20,24 @@ var CartoDatasource = require('./datasource');
  ].join('\n');
  var COMP_OP_TO_CANVAS = {
    "difference": "difference",
    "src": 'source-over',
    "exclusion": "exclusion",
    "dst": "destination-in",
    "multiply": "multiply",
    "contrast": "contrast",
    "src-over": 'source-over',
    "screen": "screen",
    "invert": "invert",
    "dst-over": 'destination-over',
    "overlay": "overlay",
    "invert-rgb": "invert",
    "src-in": 'source-in',
    "darken": 'darken',
    "dst-in": 'destination-in',
    "lighten": 'lighten',
    "src-out": 'source-out',
    "color-dodge": "color-dodge",
    "hue":"hue",
    "dst-out": 'destination-out',
    "color-burn":"color-burn",
    "saturation":"saturation",
    "src-atop": 'source-atop',
    "hard-light":"hard-light",
    "color":"color",
    "dst-atop": 'destination-atop',
-    "soft-light":"soft-light",
+    "xor": 'xor',
-    "xor": 'xor'
+    "darken": 'darken',
    "lighten": 'lighten'
  }
  function compop2canvas(compop) {
    return COMP_OP_TO_CANVAS[compop] || compop;
  }
  // Take an input cartocss that may contain comments and remove them
  var COMMENTS_RE = /\/\*.*?\*\/\n?/mg;
  function stripComments(cartocss) {
    return cartocss.replace(COMMENTS_RE, '');
  }
  //
  // this renderer just render points depending of the value
  //
@ -71,7 +46,6 @@ var CartoDatasource = require('./datasource');
      throw new Error("canvas can't be undefined");
    }
    this.options = options;
    this.layer = options.layer;
    this._canvas = canvas;
    this._ctx = canvas.getContext('2d');
    this._sprites = []; // sprites per layer
@ -90,23 +64,18 @@ var CartoDatasource = require('./datasource');
  torque.extend(PointRenderer.prototype, torque.Event, {
    clearCanvas: function() {
-      if (this._Map) {
+      var canvas = this._canvas;
-        var canvas = this._canvas;
+      var color = this._Map['-torque-clear-color']
-        var color = this._Map['-torque-clear-color']
+      // shortcut for the default value
-        // shortcut for the default value
+      if (color  === "rgba(255, 255, 255, 0)" || !color) {
        this._canvas.width = this._canvas.width;
      } else {
        var ctx = this._ctx;
-        if (color  === "rgba(255, 255, 255, 0)" || !color) {
+        ctx.setTransform(1, 0, 0, 1, 0, 0);
-          ctx.save();
+        var compop = this._Map['comp-op']
-          ctx.setTransform(1, 0, 0, 1, 0, 0);
+        ctx.globalCompositeOperation = compop2canvas(compop);
-          ctx.clearRect(0, 0, canvas.width, canvas.height);
+        ctx.fillStyle = color;
-          ctx.restore();
+        ctx.fillRect(0, 0, canvas.width, canvas.height);
        } else {
          ctx.setTransform(1, 0, 0, 1, 0, 0);
          var compop = this._Map['comp-op']
          ctx.globalCompositeOperation = compop2canvas(compop) || compop;
          ctx.fillStyle = color;
          ctx.fillRect(0, 0, canvas.width, canvas.height);
        }
      }
    },
@ -118,27 +87,9 @@ var CartoDatasource = require('./datasource');
    //
    // sets the cartocss style to render stuff
    //
-    setCartoCSS: function(cartocss, callback) {
+    setCartoCSS: function(cartocss) {
-      var self = this;
+      // clean sprites
-
+      this.setShader(new carto.RendererJS().render(cartocss));
      this.style = stripComments(cartocss);
      if (PointRenderer.isTurboCarto(this.style) && self.layer) {
        var datasource = new CartoDatasource(self.layer._tiles);
        turbocarto(this.style, datasource, function (err, parsedCartoCSS) {
          if (err) {
            return callback(err, null);
          }
          self.setShader(new carto.RendererJS().render(parsedCartoCSS));
          self.layer.redraw();
          self.layer.animator.start();
          callback && callback();
        });
      } else {
        self.setShader(new carto.RendererJS().render(this.style));
        callback && callback();
      }
    },
    setShader: function(shader) {
@ -147,10 +98,6 @@ var CartoDatasource = require('./datasource');
      this._shader = shader;
      this._Map = this._shader.getDefault().getStyle({}, { zoom: 0 });
      var img_names = this._shader.getImageURLs();
      if (this.layer && this.layer.showLimitErrors) {
        img_names.push(ERROR_IMG_URL);
      }
      this._preloadIcons(img_names);
    },
@ -226,12 +173,6 @@ var CartoDatasource = require('./datasource');
    // renders all the layers (and frames for each layer) from cartocss
    //
    renderTile: function(tile, keys, callback) {
      if (tile && tile.error) {
        this._renderErrorTile(tile);
        return false;
      }
      if (this._iconsToLoad > 0) {
          this.on('allIconsLoaded', function() {
              this.renderTile.apply(this, [tile, keys, callback]);
@ -255,15 +196,7 @@ var CartoDatasource = require('./datasource');
            var frame = layer.frames()[fr];
            var fr_sprites = sprites[frame] || (sprites[frame] = []);
            for (var k = 0, len = keys.length; k < len; k++) {
-              try {
+              this._renderTile(tile, keys[k] - frame, frame, fr_sprites, layer);
                this._renderTile(tile, keys[k] - frame, frame, fr_sprites, layer);
              } catch (error) {
                if (callback) {
                  return callback(error);
                }
                throw new Error(error);
              }
            }
          }
        }
@ -311,13 +244,6 @@ var CartoDatasource = require('./datasource');
      }
    },
    _renderErrorTile: function(tile) {
      if(this.layer.showLimitErrors) {
        var img = this._icons[ERROR_IMG_URL];
        img && this._ctx.drawImage(img, 0, 0, this.TILE_SIZE, this.TILE_SIZE);
      }
    },
    //
    // renders a tile in the canvas for key defined in 
    // the torque tile
@ -351,7 +277,7 @@ var CartoDatasource = require('./datasource');
           if (sp) {
             var x = tile.x[posIdx]- (sp.width >> 1) + anchor;
             var y = tileMax - tile.y[posIdx] + anchor; // flip mercator
-            ctx.drawImage(sp, x, y - (sp.height >> 1));
+             ctx.drawImage(sp, x, y - (sp.height >> 1));
           }
          }
        }
@ -499,58 +425,47 @@ var CartoDatasource = require('./datasource');
      } else {
          this.fire("allIconsLoaded");
      }
-    },
+  },
-    applyFilters: function(){
+  applyFilters: function(){
-      if(this._style){
+    if(this._style){
-        if(this._style['image-filters']){
+      if(this._style['image-filters']){
-          function gradientKey(imf){
+        function gradientKey(imf){
-            var hash = ""
+          var hash = ""
-            for(var i = 0; i < imf.args.length; i++){
+          for(var i = 0; i < imf.args.length; i++){
-              var rgb = imf.args[i].rgb;
+            var rgb = imf.args[i].rgb;
-              hash += rgb[0] + ":" + rgb[1] + ":" + rgb[2];
+            hash += rgb[0] + ":" + rgb[1] + ":" + rgb[2];
            }
            return hash;
          }
-          var gradient = this._gradients[gradientKey(this._style['image-filters'])];
+          return hash;
          if(!gradient){
            function componentToHex(c) {
              var hex = c.toString(16);
              return hex.length == 1 ? "0" + hex : hex;
            }
            function rgbToHex(r, g, b) {
              return "#" + componentToHex(r) + componentToHex(g) + componentToHex(b);
            }
            gradient = {};
            var colorize = this._style['image-filters'].args;
            var increment = 1/colorize.length;
            for (var i = 0; i < colorize.length; i++){
              var key = increment * i + increment;
              var rgb = colorize[i].rgb;
              var formattedColor = rgbToHex(rgb[0], rgb[1], rgb[2]);
              gradient[key] = formattedColor;
            }
            this._gradients[gradientKey(this._style['image-filters'])] = gradient;
          }
          this._filters.gradient(gradient);
          this._filters.draw();
        }
        var gradient = this._gradients[gradientKey(this._style['image-filters'])];
        if(!gradient){
          function componentToHex(c) {
            var hex = c.toString(16);
            return hex.length == 1 ? "0" + hex : hex;
          }
          function rgbToHex(r, g, b) {
            return "#" + componentToHex(r) + componentToHex(g) + componentToHex(b);
          }
          gradient = {};
          var colorize = this._style['image-filters'].args;
          var increment = 1/colorize.length;
          for (var i = 0; i < colorize.length; i++){
            var key = increment * i + increment;
            var rgb = colorize[i].rgb;
            var formattedColor = rgbToHex(rgb[0], rgb[1], rgb[2]);
            gradient[key] = formattedColor;
          }
          this._gradients[gradientKey(this._style['image-filters'])] = gradient;
        }
        this._filters.gradient(gradient);
        this._filters.draw();
      }
    }
-  });
+  }
-
+});
 PointRenderer.isTurboCarto = function (cartocss) {
  var reservedWords = ['ramp', 'colorbrewer', 'buckets']
  var isTurbo = reservedWords
    .map(function (w) {
      return w + '('
    })
    .map(String.prototype.indexOf.bind(cartocss))
    .every(function (f) { return f === -1 })
  return !isTurbo
 }
  // exports public api
--- a/lib/torque/request.js
+++ b/lib/torque/request.js
@ -62,7 +62,7 @@ var torque = require('./core');
    function respond() {
      var status = req.status, result;
      var r = options.responseType === 'arraybuffer' ? req.response: req.responseText;
-      if (!status && r || status >= 200 && status < 300 || status === 304 || status === 429) {
+      if (!status && r || status >= 200 && status < 300 || status === 304) {
        callback(req);
      } else {
        callback(null);
--- a/package-lock.json
+++ b/package-lock.json
--- a/package.json
+++ b/package.json
@ -1,56 +1,49 @@
 {
-  "name": "torque.js",
+    "name": "torque.js",
-  "version": "3.1.2",
+    "version": "2.15.1",
-  "description": "Temporal mapping for CARTO",
+    "description": "Temporal mapping for CartoDB",
-  "repository": {
+    "repository": {
-    "type": "git",
+        "type": "git",
-    "url": "git://github.com/CartoDB/torque.git"
+        "url": "git://github.com/CartoDB/torque.git"
-  },
+    },
-  "author": {
+    "author": {
-    "name": "CARTO",
+        "name": "CartoDB",
-    "url": "http://carto.com/",
+        "url": "http://cartodb.com/",
-    "email": "wadus@carto.com"
+        "email": "wadus@cartodb.com"
-  },
+    },
-  "contributors": [
+    "contributors": [
-    "Andrew Hill <andrew@vizzuality.com>",
+        "Andrew Hill <andrew@vizzuality.com>",
-    "Simon Tokumine <tokumine@google.com>",
+        "Simon Tokumine <tokumine@google.com>",
-    "Javier Alvarez <jmedina@vizzuality.com>",
+        "Javier Alvarez <jmedina@vizzuality.com>",
-    "Javier Arce <javierarce@vizzuality.com>",
+        "Javier Arce <javierarce@vizzuality.com>",
-    "Javier Santana <jsantana@vizzuality.com>",
+        "Javier Santana <jsantana@vizzuality.com>",
-    "Raúl Ochoa <rochoa@cartodb.com>",
+        "Raúl Ochoa <rochoa@cartodb.com>",
-    "Nicklas Gummesson <nicklas@cartodb.com>",
+        "Nicklas Gummesson <nicklas@cartodb.com>",
-    "Francisco Dans <francisco@cartodb.com>",
+        "Francisco Dans <francisco@cartodb.com>"
-    "Carlos Matallín <matallo@carto.com>",
+    ],
-    "Rubén Moya <ruben@carto.com>",
+    "licenses": [{
-    "Daniel García Aubert <dgaubert@carto.com>"
+      "type": "BSD"
    }
  ],
  "license": "BSD-3-Clause",
  "dependencies": {
-    "carto": "cartodb/carto#master",
+    "carto": "https://github.com/CartoDB/carto/archive/master.tar.gz"
    "d3": "3.5.17",
    "turbo-carto": "^0.21.1",
    "turf-jenks": "~1.0.1"
  },
  "devDependencies": {
-    "@carto/mapnik": "^3.6.2-carto.11",
+    "browserify": "^7.0.0",
-    "browserify": "^16.2.3",
+    "canvas": "~1.2.1",
-    "canvas": "^2.4.1",
+    "leaflet": "0.7.3",
-    "leaflet": "1.0.3",
+    "mapnik": "https://github.com/CartoDB/node-mapnik/tarball/1.4.15-cdb1",
-    "node-qunit-phantomjs": "1.6.0",
+    "node-qunit-phantomjs": "^1.0.0",
-    "phantomjs-polyfill": "0.0.2",
+    "phantomjs-polyfill": "0.0.1",
-    "qunit": "~0.7.7",
+    "qunit": "~0.7.5",
    "qunitjs": "1.x",
-    "request": "^2.88.0",
+    "request": "^2.53.0",
-    "sinon": "~1.15.4",
+    "uglify-js": "1.3.3",
-    "uglify-js": "^3.4.9",
+    "underscore": "^1.6.0",
-    "underscore": "1.8.3"
+    "sinon": "^1.15.4"
  },
  "scripts": {
-    "test": "make test-all",
+    "test": "make test-all"
    "bump": "npm version patch",
    "bump:major": "npm version major",
    "bump:minor": "npm version minor",
    "postversion": "git push origin master --follow-tags"
  },
  "main": "./lib/torque/index.js"
 }
--- a/test/acceptance/example.js
+++ b/test/acceptance/example.js
@ -1,12 +1,12 @@
-const { createCanvas }= require('canvas');
+var Canvas = require('canvas');
-const image = require('../support/image');
+var image = require('../support/image');
 QUnit.module('example');
 test('reference test with canvas', function() {
    var circleRadius = 20;
    var canvasSize = circleRadius * 2 + 2;
-    var canvas = createCanvas(canvasSize, canvasSize);
+    var canvas = new Canvas(canvasSize, canvasSize);
    var ctx = canvas.getContext('2d');
@ -19,3 +19,4 @@ test('reference test with canvas', function() {
    equal(imageDiff, 0);
 });
--- a/test/animator.js
+++ b/test/animator.js
@ -10,9 +10,9 @@ test('time moves', function(assert) {
 	animatora.start();
 	setTimeout(function(){
 		assert.notEqual(animatora._time, 0);
 		animatora.pause();
 		done();
 	}, 20)
 	animatora.pause();
 });
 test("rescale should resume animation if previously playing", function(assert){
--- a/test/provider.json.js
+++ b/test/provider.json.js
@ -1,22 +1,8 @@
 var torque = require('../lib/torque');
 var providers = torque.providers;
-var json, url, _XMLHttpRequest;
+var json, url;
 QUnit.module('provider.json');
 QUnit.moduleStart(function() {
  _XMLHttpRequest = window.XMLHttpRequest;
  window.XMLHttpRequest = function () {
    return {
      open: function () { },
      send: function () { },
      readyState: 4,
      responseText: {}
    }
  };
 });
 QUnit.moduleDone(function() {
  window.XMLHttpRequest = _XMLHttpRequest;
 });
 QUnit.testStart(function() {
    json = new providers.json({
      table: 'test',
--- a/test/provider.windshaft.test.js
+++ b/test/provider.windshaft.test.js
@ -83,7 +83,7 @@ QUnit.module('provider.windshaft', {
  test("fetch tile", function() {
    windshaft._ready = true;
-    windshaft.getTileData({x: 0, y: 1, corrected: {x: 0, y: 1}}, 2, function() {}, function() {});
+    windshaft.getTileData({x: 0, y: 1, corrected: {x: 0, y: 1}}, 2, function() {});
    equal(lastCall,"http://rambo.cartodb.com:80/api/v1/map/testlg/0/2/0/1.json.torque?testing=abcd%25");
  });
--- a/test/renderer/point.js
+++ b/test/renderer/point.js
@ -22,11 +22,7 @@ var DEFAULT_CARTOCSS = [
 var renderer = null;
 QUnit.testStart(function() {
    var canvas = document.createElement('canvas');
-    renderer = new torque.renderer.Point(canvas, {
+    renderer = new torque.renderer.Point(canvas, {});
      layer: {
        showLimitErros: false
      }
    });
 });
 test('render shader layers', function() {
@ -137,38 +133,3 @@ test('get values for tile', function() {
  equal(v[0], 5);
  equal(v[1], 7);
 });
 test('should deal with no layer and commented out cartocss', function() {
  var css = [
    'Map {',
    '  -torque-frame-count: 1;',
    '  -torque-animation-duration: 30;',
    '  -torque-time-attribute: "cartodb_id";',
    '  -torque-aggregation-function: "count(1)";',
    '  -torque-resolution: 4;',
    '  -torque-data-aggregation: linear;',
    '}',
    '#layer {',
    '  marker-width: 16.6;',
    '  /*marker-width: ramp([value], range(2, 40), jenks(6));*/',
    '  marker-fill-opacity: 1;',
    '  marker-file: url(http://cartodb-libs.global.ssl.fastly.net/cartodbui/assets/unversioned/images/alphamarker.png);',
    '  marker-allow-overlap: true;',
    '  marker-line-width: 1;',
    '  marker-line-color: #FFFFFF;',
    '  marker-line-opacity: 1;',
    '  marker-comp-op: darken;',
    '  image-filters: colorize-alpha(#4b2991,#872ca2,#c0369d,#ea4f88,#fa7876,#f6a97a,#edd9a3);',
    '}'
  ].join('\n');
  var canvas = document.createElement('canvas');
  var myRenderer = new torque.renderer.Point(canvas, {
    layer: undefined
  });
  myRenderer.setCartoCSS(css);
  var shader = renderer._shader.getLayers()[0];
  var sprite = myRenderer.generateSprite(shader, 0, { zoom: 0 });
  notEqual(sprite, null);
 });
--- a/test/suite-bundle.js
+++ b/test/suite-bundle.js
--- a/test/support/image.js
+++ b/test/support/image.js
@ -1,4 +1,4 @@
-var mapnik = require('@carto/mapnik');
+var mapnik = require('mapnik');
 function compare(buffer, fixtureRelPath) {
    save(__dirname + '/../results/' + fixtureRelPath, buffer);
--- a/test/support/point_renderer.js
+++ b/test/support/point_renderer.js
@ -1,4 +1,4 @@
-const { createCanvas, Canvas, Image }= require('canvas');
+var Canvas = require('canvas');
 var request = require('request');
 var _ = require('underscore');
 var fs = require('fs');
@ -14,7 +14,7 @@ function getTile(jsonRelPath, cartocss, z, x, y, step, callback) {
    var provider = new torque.providers.windshaft(_.extend({ no_fetch_map: true }, cartoCssOptions));
    var rendererOptions = _.extend({cartocss: cartocss}, cartoCssOptions, {
        canvasClass: Canvas,
-        imageClass: Image,
+        imageClass: Canvas.Image,
        setImageSrc: function(img, url, callback) {
            var requestOpts = {
                url: url,
@ -37,15 +37,12 @@ function getTile(jsonRelPath, cartocss, z, x, y, step, callback) {
        },
        qualifyURL: function(url) {
            return url;
        },
        layer: {
            showLimitErros: false
        }
    });
    var rows = JSON.parse(fs.readFileSync(__dirname + '/../fixtures/json/' + jsonRelPath));
-    var canvas = createCanvas(256, 256);
+    var canvas = new Canvas(256, 256);
    var pointRenderer = new torque.renderer.Point(canvas, rendererOptions);
    pointRenderer.renderTile(provider.proccessTile(rows, {x: x, y: y}, z), step, function(err) {
		`@ -1,3 +0,0 @@`
			`## Versioning`

			`Torque.js uses [Semantic Versioning](http://semver.org/). View our Github repository to find tags for each [release](https://github.com/CartoDB/torque/releases).`