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'
-before_install:
-  - if [ "$CXX" = "g++" ]; then export CXX="g++-4.9" CC="gcc-4.9"; fi
+  - "0.10"
 addons:
  apt:
-    sources:
-      - ubuntu-toolchain-r-test
    packages:
-      - pkg-config
-      - libcairo2-dev
-      - libpango1.0-dev
-      - libjpeg8-dev
-      - libgif-dev
-      - gcc-4.9
-      - g++-4.9
+    - pkg-config
+    - libcairo2-dev
+    - libjpeg8-dev
+    - libgif-dev
 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/49
+++ b/49
@ -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)
@ -58,7 +15,7 @@ v2.16.4
    - Added getValues to fetch values for step
    - Improved reference/api documentation
    - Removed out of date examples
-
+    
 2.11.4
    - Static torque maps now draw correctly when unhiding them
    - Fixed animation always playing when rescaling
@ -103,7 +60,7 @@ v2.16.4
    - Improved out of bounds correction function
    - Fixed image-asset sizing
    - Fixed items to load counter being sometimes negative
-
+    
 2.8.0
    - Supports use of external image markers via marker-file
    - Fixes Torque tiles not rendering outside normal lat/lng ranges.
--- 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
-
-```javascript
-  ...
-  <body>
-    <div id="map"></div>
-    ...
-    <script>
+<div class="margin20"></div>
+<div class="code_title">Create a simple Torque visualization</div>
+  ``` javascript
+      ...
+        <body>
+          <div id="map"></div>
+        </body>
+      ...
      // 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="https://libs.cartocdn.com/torque.js/2.16.5/torque.full.js"></script>
+    <script src="http://maps.googleapis.com/maps/api/js?sensor=false"></script>
+    <script src="../dist/torque.full.uncompressed.js"></script>


    <script>
@ -55,8 +55,7 @@
        steps: 1024,
        blendmode  : 'lighter',
        animationDuration: 20,
-        map: map,
-        tiler_protocol: 'https'
+        map: map
      });

    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="https://libs.cartocdn.com/torque.js/2.16.5/torque.full.js"></script>
+    <script src="vendor/leaflet.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,
-        tiler_protocol: 'https',
-        tiler_port: 443,
-        zIndex: 10
+        cartocss: CARTOCSS
      });
      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" />
-    <script src="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.3.4/leaflet.js"></script>
+    <link rel="stylesheet" href="http://cdn.leafletjs.com/leaflet-0.7.3/leaflet.css" />
+    <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,
-        tiler_protocol: 'https',
-        tiler_port: 443,
-        zIndex: 10
+        cartocss: CARTOCSS
      });
      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="https://libs.cartocdn.com/torque.js/2.16.5/torque.full.js"  type="application/javascript" charset="utf-8"></script>
+    <script src="http://maps.googleapis.com/maps/api/js?sensor=false"></script>
+    <script src="../dist/torque.full.uncompressed.js"></script>


    <script>
@ -75,8 +75,7 @@
        user       : 'viz2',
        table      : 'ow',
        cartocss: CARTOCSS,
-        tiler_protocol: 'https',
-        tiler_port: 443
+        map: map
      });
      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="https://cdnjs.cloudflare.com/ajax/libs/leaflet/1.3.4/leaflet.js"></script>
-    <script src="https://libs.cartocdn.com/torque.js/2.16.5/torque.full.js"  type="application/javascript" charset="utf-8"></script>
+    <script src="vendor/leaflet.js"></script>
+    <script src="../dist/torque.full.uncompressed.js"></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,
-        tiler_protocol: 'https',
-        tiler_port: 443
+        cartocss: CARTOCSS
      });
      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="https://libs.cartocdn.com/torque.js/2.16.5/torque.full.js"></script>
+    <script src="vendor/leaflet.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,
-        tiler_protocol: 'https',
-        tiler_port: 443,
-        zIndex: 10
+        cartocss: CARTOCSS
      });
      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) {
-			return console.error(err);
+		if(!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() {
@ -250,7 +241,7 @@ GMapsTorqueLayer.prototype = torque.extend({},
    this.setKeys([key]);
  },

-  /**
+  /** 
   * returns the array of keys being rendered
   */
  getKeys: 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) {
-      console.log('Torque layer: CartoCSS style on named maps is read-only');
-      return false;
-    }
-
+    if (this.provider && this.provider.options.named_map) throw new Error("CartoCSS style on named maps is read-only");
    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],

@ -64,7 +64,7 @@ L.CanvasLayer = L.Layer.extend({
    this._map = map;

    // add container with the canvas to the tile pane
-    // the container is moved in the oposite direction of the
+    // the container is moved in the oposite direction of the 
    // map pane to keep the canvas always in (0, 0)
    var tilePane = this._map._panes.tilePane;
    var _container = L.DomUtil.create('div', 'leaflet-layer');
@ -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
-      var headerCartoCSS = options.cartocss.replace(/\n/g,'').match(/Map\s*?\{.*?}/g)[0];
-      torque.extend(options, torque.common.TorqueLayer.optionsFromCartoCSS(headerCartoCSS));
+      torque.extend(options, torque.common.TorqueLayer.optionsFromCartoCSS(options.cartocss));
    }

    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
@ -303,7 +286,7 @@ L.TorqueLayer = L.CanvasLayer.extend({
    this.setKeys([key], options);
  },

-  /**
+  /** 
   * returns the array of keys being rendered
   */
  getKeys: function() {
@ -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) {
-      console.log('Torque layer: CartoCSS style on named maps is read-only');
-      return false;
+    // 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();
    }

-    this.renderer.setCartoCSS(cartocss, function () {
-      // 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));
+    torque.extend(this.options, options);

+    // 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,22 +186,11 @@
      };
    },

-    proccessTileError: function(error, coord, zoom) {
-      return {
-        error: error,
-        coord: {
-          x: coord.x,
-          y: coord.y,
-          z: zoom
-        }
-      };
-    },
-
    /*setCartoCSS: function(c) {
      this.options.cartocss = c;
    },*/

-    setSteps: function(steps, opt) {
+    setSteps: function(steps, opt) { 
      opt = opt || {};
      if (this.options.steps !== steps) {
        this.options.steps = steps;
@ -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) {
-          var body = JSON.parse(response.responseText);
-
-          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));
-          }
+        if (data && data.responseText) {
+          var rows = JSON.parse(data.responseText);
+          callback(self.proccessTile(rows, coord, zoom));
        } else {
          Profiler.metric('torque.provider.windshaft.tile.error').inc();
          callback(null);
@ -457,7 +439,7 @@
          }]
        };
      }
-
+      
      if(this.options.stat_tag){
        allParams["stat_tag"] = this.options.stat_tag;
      }
--- 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
@ -83,30 +57,25 @@ var CartoDatasource = require('./datasource');
    this.TILE_SIZE = 256;
    this._style = null;
    this._gradients = {};
-
+    
    this._forcePoints = false;
  }

  torque.extend(PointRenderer.prototype, torque.Event, {

    clearCanvas: function() {
-      if (this._Map) {
-        var canvas = this._canvas;
-        var color = this._Map['-torque-clear-color']
-        // shortcut for the default value
+      var canvas = this._canvas;
+      var color = this._Map['-torque-clear-color']
+      // 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.save();
-          ctx.setTransform(1, 0, 0, 1, 0, 0);
-          ctx.clearRect(0, 0, canvas.width, canvas.height);
-          ctx.restore();
-        } 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);
-        }
+        ctx.setTransform(1, 0, 0, 1, 0, 0);
+        var compop = this._Map['comp-op']
+        ctx.globalCompositeOperation = compop2canvas(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) {
-      var self = this;
-
-      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();
-      }
+    setCartoCSS: function(cartocss) {
+      // clean sprites
+      this.setShader(new carto.RendererJS().render(cartocss));
    },

    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);
    },

@ -218,7 +165,7 @@ var CartoDatasource = require('./datasource');
        i.src = canvas.toDataURL();
        return i;
      }
-
+      
      return canvas;
    },

@ -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,20 +196,12 @@ 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);
-              } catch (error) {
-                if (callback) {
-                  return callback(error);
-                }
-
-                throw new Error(error);
-              }
+              this._renderTile(tile, keys[k] - frame, frame, fr_sprites, layer);
            }
          }
        }
      }
-
+      
      prof.end(true);

      return callback && callback(null);
@ -311,15 +244,8 @@ 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
+    // renders a tile in the canvas for key defined in 
    // the torque tile
    //
    _renderTile: function(tile, key, frame_offset, sprites, shader, shaderVars) {
@ -351,12 +277,12 @@ 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));
           }
          }
        }
      }
-
+      

      prof.end(true);
    },
@ -499,58 +425,47 @@ var CartoDatasource = require('./datasource');
      } else {
          this.fire("allIconsLoaded");
      }
-    },
+  },

-    applyFilters: function(){
-      if(this._style){
-        if(this._style['image-filters']){
-          function gradientKey(imf){
-            var hash = ""
-            for(var i = 0; i < imf.args.length; i++){
-              var rgb = imf.args[i].rgb;
-              hash += rgb[0] + ":" + rgb[1] + ":" + rgb[2];
-            }
-            return hash;
+  applyFilters: function(){
+    if(this._style){
+      if(this._style['image-filters']){
+        function gradientKey(imf){
+          var hash = ""
+          for(var i = 0; i < imf.args.length; i++){
+            var rgb = imf.args[i].rgb;
+            hash += rgb[0] + ":" + rgb[1] + ":" + rgb[2];
          }
-          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();
+          return hash;
        }
+        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
@ -27,9 +27,9 @@ var torque = require('./core');
     };

     // timeout for errors
-     var timeoutTimer = setTimeout(function() {
+     var timeoutTimer = setTimeout(function() { 
       clean();
-       callback.call(window, null);
+       callback.call(window, null); 
     }, options.timeout);

     // setup url
@ -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",
-  "version": "3.1.2",
-  "description": "Temporal mapping for CARTO",
-  "repository": {
-    "type": "git",
-    "url": "git://github.com/CartoDB/torque.git"
-  },
-  "author": {
-    "name": "CARTO",
-    "url": "http://carto.com/",
-    "email": "wadus@carto.com"
-  },
-  "contributors": [
-    "Andrew Hill <andrew@vizzuality.com>",
-    "Simon Tokumine <tokumine@google.com>",
-    "Javier Alvarez <jmedina@vizzuality.com>",
-    "Javier Arce <javierarce@vizzuality.com>",
-    "Javier Santana <jsantana@vizzuality.com>",
-    "Raúl Ochoa <rochoa@cartodb.com>",
-    "Nicklas Gummesson <nicklas@cartodb.com>",
-    "Francisco Dans <francisco@cartodb.com>",
-    "Carlos Matallín <matallo@carto.com>",
-    "Rubén Moya <ruben@carto.com>",
-    "Daniel García Aubert <dgaubert@carto.com>"
+    "name": "torque.js",
+    "version": "2.15.1",
+    "description": "Temporal mapping for CartoDB",
+    "repository": {
+        "type": "git",
+        "url": "git://github.com/CartoDB/torque.git"
+    },
+    "author": {
+        "name": "CartoDB",
+        "url": "http://cartodb.com/",
+        "email": "wadus@cartodb.com"
+    },
+    "contributors": [
+        "Andrew Hill <andrew@vizzuality.com>",
+        "Simon Tokumine <tokumine@google.com>",
+        "Javier Alvarez <jmedina@vizzuality.com>",
+        "Javier Arce <javierarce@vizzuality.com>",
+        "Javier Santana <jsantana@vizzuality.com>",
+        "Raúl Ochoa <rochoa@cartodb.com>",
+        "Nicklas Gummesson <nicklas@cartodb.com>",
+        "Francisco Dans <francisco@cartodb.com>"
+    ],
+    "licenses": [{
+      "type": "BSD"
+    }
  ],
-  "license": "BSD-3-Clause",
  "dependencies": {
-    "carto": "cartodb/carto#master",
-    "d3": "3.5.17",
-    "turbo-carto": "^0.21.1",
-    "turf-jenks": "~1.0.1"
+    "carto": "https://github.com/CartoDB/carto/archive/master.tar.gz"
  },
  "devDependencies": {
-    "@carto/mapnik": "^3.6.2-carto.11",
-    "browserify": "^16.2.3",
-    "canvas": "^2.4.1",
-    "leaflet": "1.0.3",
-    "node-qunit-phantomjs": "1.6.0",
-    "phantomjs-polyfill": "0.0.2",
-    "qunit": "~0.7.7",
+    "browserify": "^7.0.0",
+    "canvas": "~1.2.1",
+    "leaflet": "0.7.3",
+    "mapnik": "https://github.com/CartoDB/node-mapnik/tarball/1.4.15-cdb1",
+    "node-qunit-phantomjs": "^1.0.0",
+    "phantomjs-polyfill": "0.0.1",
+    "qunit": "~0.7.5",
    "qunitjs": "1.x",
-    "request": "^2.88.0",
-    "sinon": "~1.15.4",
-    "uglify-js": "^3.4.9",
-    "underscore": "1.8.3"
+    "request": "^2.53.0",
+    "uglify-js": "1.3.3",
+    "underscore": "^1.6.0",
+    "sinon": "^1.15.4"
  },
  "scripts": {
-    "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"
+    "test": "make test-all"
  },
  "main": "./lib/torque/index.js"
 }
--- a/test/acceptance/example.js
+++ b/test/acceptance/example.js
@ -1,12 +1,12 @@
-const { createCanvas }= require('canvas');
-const image = require('../support/image');
+var Canvas = require('canvas');
+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
@ -26,7 +26,7 @@ QUnit.module('provider.windshaft', {
        testing: 'abcd%'
      }
    });
-  },
+  }, 
  teardown: function() {
    torque.net.jsonp = old_net;
    torque.net.get = old_get;
@ -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, {
-      layer: {
-        showLimitErros: false
-      }
-    });
+    renderer = new torque.renderer.Point(canvas, {});
 });

 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) {