diff --git a/bower_components/connector/.bower.json b/bower_components/connector/.bower.json new file mode 100644 index 00000000..c68b5ffc --- /dev/null +++ b/bower_components/connector/.bower.json @@ -0,0 +1,40 @@ +{ + "name": "connector", + "authors": [ + "Kevin Jahns " + ], + "description": "Connect to other users via a generic connector. The interface is standardized, so you can use other connectors without changing your code.", + "main": [ + "peerjs-connector/peerjs-connector.min.js", + "peerjs-connector/peerjs-connector.html" + ], + "moduleType": [ + "globals", + "node" + ], + "keywords": [ + "peerjs" + ], + "license": "MIT", + "ignore": [ + "**/.*", + "node_modules", + "bower_components", + "test", + "tests" + ], + "dependencies": { + "polymer": "Polymer/polymer#~0.5.1" + }, + "homepage": "https://github.com/DadaMonad/Connector", + "_release": "35f8d81ce7", + "_resolution": { + "type": "branch", + "branch": "master", + "commit": "35f8d81ce73ecac317b3dd7fabf32a871a4926a6" + }, + "_source": "git://github.com/DadaMonad/Connector.git", + "_target": "*", + "_originalSource": "DadaMonad/Connector", + "_direct": true +} \ No newline at end of file diff --git a/bower_components/connector/README.md b/bower_components/connector/README.md new file mode 100644 index 00000000..33c4bac0 --- /dev/null +++ b/bower_components/connector/README.md @@ -0,0 +1,13 @@ + +# Connector-Interface +The idea is, to create different implementations of the Connector interface that enable communication within a group. +It has a minimal interface and covers some frequently occuring problems thay you probably will encounter if you use communitcation protocols directly. + +E.g. You can exchange the PeerJs-Connector with the XMPP-Connector only by changing few lines of code. + +It is the communication interface used by [Yatta](https://github.com/DadaMonad/Yatta). + +Currently we have interfaces for: +* PeerJs + +More information about the Connector interface will follow. (Trust the update frequency, this could be a lie) diff --git a/bower_components/connector/bower.json b/bower_components/connector/bower.json new file mode 100644 index 00000000..a2b7cd06 --- /dev/null +++ b/bower_components/connector/bower.json @@ -0,0 +1,30 @@ +{ + "name": "connector", + "version": "0.0.0", + "authors": [ + "Kevin Jahns " + ], + "description": "Connect to other users via a generic connector. The interface is standardized, so you can use other connectors without changing your code.", + "main": [ + "peerjs-connector/peerjs-connector.min.js", + "peerjs-connector/peerjs-connector.html" + ], + "moduleType": [ + "globals", + "node" + ], + "keywords": [ + "peerjs" + ], + "license": "MIT", + "ignore": [ + "**/.*", + "node_modules", + "bower_components", + "test", + "tests" + ], + "dependencies": { + "polymer": "Polymer/polymer#~0.5.1" + } +} diff --git a/bower_components/connector/gulpfile.coffee b/bower_components/connector/gulpfile.coffee new file mode 100644 index 00000000..3b980680 --- /dev/null +++ b/bower_components/connector/gulpfile.coffee @@ -0,0 +1,50 @@ +gulp = require 'gulp' +coffee = require 'gulp-coffee' +concat = require 'gulp-concat' +uglify = require 'gulp-uglify' +sourcemaps = require 'gulp-sourcemaps' +plumber = require 'gulp-plumber' +browserify = require 'gulp-browserify' +rename = require 'gulp-rename' + +paths = + peerjs: ['./lib/peerjs-connector/**/*.coffee'] + test: ['./lib/test-connector/**/*.coffee'] + + + +buildConnector = (connector_name)-> + ()-> + gulp.src(paths[connector_name], {read: false}) + .pipe(plumber()) + .pipe browserify + transform: ['coffeeify'] + extensions: ['.coffee'] + debug: true + .pipe rename + extname: ".js" + .pipe gulp.dest('./'+connector_name+'-connector') + .pipe uglify() + .pipe rename + extname: ".min.js" + .pipe gulp.dest('./'+connector_name+'-connector') + +gulp.task 'peerjs', [], buildConnector 'peerjs' +gulp.task 'test', [], buildConnector 'test' +gulp.task 'build', ['peerjs','test'] + +# Rerun the task when a file changes +gulp.task 'watch', ()-> + gulp.watch(paths.peerjs, ['peerjs']) + gulp.watch(paths.test, ['test']) + +gulp.task('default', ['watch', 'build']) + + + + + + + + + diff --git a/bower_components/connector/lib/connector.coffee b/bower_components/connector/lib/connector.coffee new file mode 100644 index 00000000..d76385c5 --- /dev/null +++ b/bower_components/connector/lib/connector.coffee @@ -0,0 +1,77 @@ + +class Connector + + constructor: ()-> + # is set to true when this is synced with all other connections + @is_synced = false + # compute all of these functions when all connections are synced. + @compute_when_synced = [] + # Peerjs Connections: key: conn-id, value: conn + @connections = {} + # Connections, that have been initialized, but have not been (fully) synced yet. + @unsynced_connections = {} + # List of functions that shall process incoming data + @receive_handlers = [] + # A list of functions that are executed (left to right) when syncing with a peer. + @sync_process_order = [] + + # + # Execute a function _when_ we are connected. If not connected, wait until connected. + # @param f {Function} Will be executed on the PeerJs-Connector context. + # + whenSynced: (args)-> + if @is_synced + args[0].apply this, args[1..] + else + @compute_when_synced.push args + + # + # Execute an function _when_ a message is received. + # @param f {Function} Will be executed on the PeerJs-Connector context. f will be called with (sender_id, broadcast {true|false}, message). + # + whenReceiving: (f)-> + @receive_handlers.push f + + # + # Send a message to a (sub)-set of all connected peers. + # @param peers {Array} A set of ids. + # @param message {Object} The message to send. + # + multicast: (peers, message)-> + @whenSynced [_send, peers, message] + + # + # Send a message to one of the connected peers. + # @param peers {connection_id} A connection id. + # @param message {Object} The message to send. + # + unicast: (peer, message)-> + @whenSynced [_send, peer, message] + + # + # Broadcast a message to all connected peers. + # @param message {Object} The message to broadcast. + # + broadcast: (message)-> + @whenSynced [()=> + for peerid,peer of @connections + @_send peerid, message] + + # + # Define how you want to handle the sync process of two users. + # This is a synchronous handshake. Every user will perform exactly the same actions at the same time. E.g. + # @example + # whenSyncing(function(){ // first call must not have parameters! + # return this.id; // Send the id of this connector. + # },function(peerid){ // you receive the peerid of the other connections. + # // you can do something with the peerid + # // return "you are my friend"; // you could send another massage. + # }); // this is the end of the sync process. + # + whenSyncing: ()-> + for i in [(arguments.length-1)..0] + @sync_process_order.unshift arguments[i] + + + +module.exports = Connector diff --git a/bower_components/connector/lib/peerjs-connector/peerjs-connector-polymer.coffee b/bower_components/connector/lib/peerjs-connector/peerjs-connector-polymer.coffee new file mode 100644 index 00000000..c49115ba --- /dev/null +++ b/bower_components/connector/lib/peerjs-connector/peerjs-connector-polymer.coffee @@ -0,0 +1,29 @@ + +new Polymer 'peerjs-connector', + join: (id)-> + idChanged: (old_val,new_val)-> + if this.is_initialized + throw new Error "You must not set the user_id twice!" + else + this.initializeConnection() + + initializeConnection: ()-> + if this.conn_id? + console.log("now initializing") + options = {} + writeIfAvailable = (name, value)-> + if value? + options[name] = value + writeIfAvailable 'key', this.key + writeIfAvailable 'host', this.host + writeIfAvailable 'port', this.port + writeIfAvailable 'path', this.path + writeIfAvailable 'secure', this.secure + writeIfAvailable 'debug', this.debug + this.is_initialized = true; + this.connector = new PeerJsConnector this.conn_id, options + + ready: ()-> + if this.conn_id != null + this.initializeConnection() + diff --git a/bower_components/connector/lib/peerjs-connector/peerjs-connector.coffee b/bower_components/connector/lib/peerjs-connector/peerjs-connector.coffee new file mode 100644 index 00000000..6aa38e3f --- /dev/null +++ b/bower_components/connector/lib/peerjs-connector/peerjs-connector.coffee @@ -0,0 +1,108 @@ +Connector = require '../connector' + +window.PeerJsConnector = class PeerJsConnector extends Connector + + constructor: (@id, options)-> + super() + that = this + # The following two functions should be performed at the end of the syncing process. + # In peerjs all connection ids must be send. + @sync_process_order.push ()-> + peers = for peerid,conn of that.connections + peerid + peers + # Then connect to the connection ids. + @sync_process_order.push (peers)-> + for peerid in peers + that.join peerid + true + # Create the Peerjs instance + @conn = new Peer @id, options + # TODO: improve error handling, what happens if disconnected? provide feedback + @conn.on 'error', (err)-> + throw new Error "Peerjs connector: #{err}" + @conn.on 'disconnected', ()-> + throw new Error "Peerjs connector disconnected from signalling server. Cannot accept new connections. Not fatal, but not so good either.." + @conn.on 'disconnect', ()-> + that.conn.reconnect() + @conn.on 'connection', @_addConnection + + # + # Join a communication room. In case of peerjs, you just have to join to one other client. This connector will join to the other peers automatically. + # @param id {String} The connection id of another client. + # + join: (peerid)-> + if not @unsynced_connections[peerid]? and not @connections[peerid]? and peerid isnt @id + peer = @conn.connect peerid, {reliable: true} + @unsynced_connections[peerid] = peer + @_addConnection peer + true + else + false + + # + # Send a message to a peer or set of peers. This is peerjs specific. + # @overload _send(peerid, message) + # @param peerid {String} PeerJs connection id of _another_ peer + # @param message {Object} Some object that shall be send + # @overload _send(peerids, message) + # @param peerids {Array} PeerJs connection ids of _other_ peers + # @param message {Object} Some object that shall be send + # + _send: (peer_s, message)-> + if peer_s.constructor is [].constructor + # Throw errors _after_ the message has been send to all other peers. + # Just in case a connection is invalid. + errors = [] + for peer in peer_s + try + @connection[peer].send message + catch error + errors.push(error+"") + if errors.length > 0 + throw new Error errors + else + @connections[peer_s].send message + + # + # @private + # This is a helper function that is only related to the peerjs connector. + # Connect to another peer. + _addConnection: (peer)=> + peer.on 'open', ()=> + that = @ + peer.send that.sync_process_order[0]() + current_sync_i = 1 + peer.on 'data', (data)-> + console.log("receive data: #{JSON.stringify data}") + if current_sync_i < that.sync_process_order.length + peer.send that.sync_process_order[current_sync_i++].call that, data + else if current_sync_i is that.sync_process_order.length + # All sync functions have been called. Increment current_sync_i one last time + current_sync_i++ + # add it to the connections object + delete that.unsynced_connections[peer.peer] + that.connections[peer.peer] = peer + # when the conn closes, delete it from the connections object + peer.on 'close', ()-> + delete that.connections[peer.peer] + # helper fkt. true iff os is an object that does not hold enumerable properties + isEmpty = (os)-> + for o of os + return false + return true + if isEmpty(that.unsynced_connections) + # there are no unsynced connections. we are now synced. + # therefore execute all fkts in this.compute_when_synced + that.is_synced = true + for comp in that.compute_when_synced + comp[0].apply that, comp[1..] + that.compute_when_synced = [] + else + # you received a new message, that is not a sync message. + # notify the receive_handlers + for f in that.receive_handlers + f peer.peer, data + + + \ No newline at end of file diff --git a/bower_components/connector/lib/test-connector/test-connector.coffee b/bower_components/connector/lib/test-connector/test-connector.coffee new file mode 100644 index 00000000..8e9c9ab5 --- /dev/null +++ b/bower_components/connector/lib/test-connector/test-connector.coffee @@ -0,0 +1,98 @@ + +_ = require "underscore" +Connector = require '../connector' + +# +# A trivial Connector that simulates network delay. +# +class TestConnector extends Connector + + # + # @param id {String} Some unique id + # @param user_connectors {Array} List of TestConnectors instances + # + constructor: (@id)-> + super() + # If you think of operations, this will mirror the + # execiton order of operations (when a message is send, or received it is put into this) + @execution_order = [] + # The messages are buffered under the name of teh sending user. + @receive_buffer = {} + @connections = {} + + @whenReceiving (user, message)=> + @execution_order.push message + @is_synced = true + + # join another user connector + join: (conn)-> + @_addConnection conn.id, conn + for cid,c of conn.connections + @_addConnection cid, c + for comp in @compute_when_synced + comp[0].apply @, comp[1..] + + + # + # @private + # This is a helper function that is only related to the peerjs connector. + # Connect to another peer. + _addConnection: (id, user_connector)-> + if not @connections[id]? and id isnt @id + data = null + user_data = null + for i in [0...@sync_process_order.length] + data_ = @sync_process_order[i].call @, user_data + user_data = user_connector.sync_process_order[i].call user_connector, data + data = data_ + @connections[id]=user_connector + user_connector.connections[@id] = @ + + # + # Get the ops in the execution order. + # + getOpsInExecutionOrder: ()-> + @execution_order + + # + # Send a message to another peer + # @param {Operation} o The operation that was executed. + # + _send: (uid, message)-> + rb = @connections[uid].receive_buffer + rb[@id] ?= [] + rb[@id].push message + + # + # Flush one operation from the line of a specific user. + # + flushOne: (uid)-> + if @receive_buffer[uid]?.length > 0 + message = @receive_buffer[uid].shift() + for f in @receive_handlers + f uid, message + + # + # Flush one operation on a random line. + # + flushOneRandom: ()-> + connlist = for cid,c of @receive_buffer + cid + @flushOne connlist[(_.random 0, (connlist.length-1))] + + # + # Flush all operations on every line. + # + flushAll: ()-> + for n,messages of @receive_buffer + for message in messages + for f in @receive_handlers + f n, message + @receive_buffer = {} + + +if window? + window.TestConnector = TestConnector + +if module? + module.exports = TestConnector diff --git a/bower_components/connector/package.json b/bower_components/connector/package.json new file mode 100644 index 00000000..7b86a3e2 --- /dev/null +++ b/bower_components/connector/package.json @@ -0,0 +1,29 @@ +{ + "name": "connector", + "version": "0.0.0", + "description": "Connect to other users via a generic interface. The interface is standardized, so you can use other connectors without changing your code. ", + "main": "peerjs-connector/peerjs-connector.js", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "keywords": [ + "peerjs" + ], + "author": "Kevin Jahns ", + "license": "MIT", + "dependencies": { + "peerjs": "~0.3.14" + }, + "devDependencies": { + "gulp-sourcemaps": "~1.2.8", + "gulp-concat": "~2.4.1", + "gulp-coffee": "~2.2.0", + "gulp-uglify": "~1.0.1", + "gulp": "~3.8.10", + "coffee-script": "~1.8.0", + "gulp-plumber": "~0.6.6", + "gulp-browserify": "~0.5.0", + "coffeeify": "~1.0.0", + "underscore": "~1.7.0" + } +} diff --git a/bower_components/connector/peerjs-connector/peerjs-connector-polymer.js b/bower_components/connector/peerjs-connector/peerjs-connector-polymer.js new file mode 100644 index 00000000..466c9fb2 --- /dev/null +++ b/bower_components/connector/peerjs-connector/peerjs-connector-polymer.js @@ -0,0 +1,41 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o + + \ No newline at end of file diff --git a/bower_components/connector/peerjs-connector/peerjs-connector.js b/bower_components/connector/peerjs-connector/peerjs-connector.js new file mode 100644 index 00000000..87bb85b5 --- /dev/null +++ b/bower_components/connector/peerjs-connector/peerjs-connector.js @@ -0,0 +1,211 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o= 0; i = _ref <= 0 ? ++_i : --_i) { + _results.push(this.sync_process_order.unshift(arguments[i])); + } + return _results; + }; + + return Connector; + +})(); + +module.exports = Connector; + + + +},{}],2:[function(require,module,exports){ +var Connector, PeerJsConnector, + __bind = function(fn, me){ return function(){ return fn.apply(me, arguments); }; }, + __hasProp = {}.hasOwnProperty, + __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }; + +Connector = require('../connector'); + +window.PeerJsConnector = PeerJsConnector = (function(_super) { + __extends(PeerJsConnector, _super); + + function PeerJsConnector(id, options) { + var that; + this.id = id; + this._addConnection = __bind(this._addConnection, this); + PeerJsConnector.__super__.constructor.call(this); + that = this; + this.sync_process_order.push(function() { + var conn, peerid, peers; + peers = (function() { + var _ref, _results; + _ref = that.connections; + _results = []; + for (peerid in _ref) { + conn = _ref[peerid]; + _results.push(peerid); + } + return _results; + })(); + return peers; + }); + this.sync_process_order.push(function(peers) { + var peerid, _i, _len; + for (_i = 0, _len = peers.length; _i < _len; _i++) { + peerid = peers[_i]; + that.join(peerid); + } + return true; + }); + this.conn = new Peer(this.id, options); + this.conn.on('error', function(err) { + throw new Error("Peerjs connector: " + err); + }); + this.conn.on('disconnected', function() { + throw new Error("Peerjs connector disconnected from signalling server. Cannot accept new connections. Not fatal, but not so good either.."); + }); + this.conn.on('disconnect', function() { + return that.conn.reconnect(); + }); + this.conn.on('connection', this._addConnection); + } + + PeerJsConnector.prototype.join = function(peerid) { + var peer; + if ((this.unsynced_connections[peerid] == null) && (this.connections[peerid] == null) && peerid !== this.id) { + peer = this.conn.connect(peerid, { + reliable: true + }); + this.unsynced_connections[peerid] = peer; + this._addConnection(peer); + return true; + } else { + return false; + } + }; + + PeerJsConnector.prototype._send = function(peer_s, message) { + var error, errors, peer, _i, _len; + if (peer_s.constructor === [].constructor) { + errors = []; + for (_i = 0, _len = peer_s.length; _i < _len; _i++) { + peer = peer_s[_i]; + try { + this.connection[peer].send(message); + } catch (_error) { + error = _error; + errors.push(error + ""); + } + } + if (errors.length > 0) { + throw new Error(errors); + } + } else { + return this.connections[peer_s].send(message); + } + }; + + PeerJsConnector.prototype._addConnection = function(peer) { + return peer.on('open', (function(_this) { + return function() { + var current_sync_i, that; + that = _this; + peer.send(that.sync_process_order[0]()); + current_sync_i = 1; + return peer.on('data', function(data) { + var comp, f, isEmpty, _i, _j, _len, _len1, _ref, _ref1, _results; + console.log("receive data: " + (JSON.stringify(data))); + if (current_sync_i < that.sync_process_order.length) { + return peer.send(that.sync_process_order[current_sync_i++].call(that, data)); + } else if (current_sync_i === that.sync_process_order.length) { + current_sync_i++; + delete that.unsynced_connections[peer.peer]; + that.connections[peer.peer] = peer; + peer.on('close', function() { + return delete that.connections[peer.peer]; + }); + isEmpty = function(os) { + var o; + for (o in os) { + return false; + } + return true; + }; + if (isEmpty(that.unsynced_connections)) { + that.is_synced = true; + _ref = that.compute_when_synced; + for (_i = 0, _len = _ref.length; _i < _len; _i++) { + comp = _ref[_i]; + comp[0].apply(that, comp.slice(1)); + } + return that.compute_when_synced = []; + } + } else { + _ref1 = that.receive_handlers; + _results = []; + for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) { + f = _ref1[_j]; + _results.push(f(peer.peer, data)); + } + return _results; + } + }); + }; + })(this)); + }; + + return PeerJsConnector; + +})(Connector); + + + +},{"../connector":1}]},{},[2]) +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/codio/workspace/node_modules/gulp-browserify/node_modules/browserify/node_modules/browser-pack/_prelude.js","/home/codio/workspace/lib/connector.coffee","/home/codio/workspace/lib/peerjs-connector/peerjs-connector.coffee"],"names":[],"mappings":"AAAA;ACCA,IAAA,SAAA;;AAAA;AAEe,EAAA,mBAAA,GAAA;AAEX,IAAA,IAAC,CAAA,SAAD,GAAa,KAAb,CAAA;AAAA,IAEA,IAAC,CAAA,mBAAD,GAAuB,EAFvB,CAAA;AAAA,IAIA,IAAC,CAAA,WAAD,GAAe,EAJf,CAAA;AAAA,IAMA,IAAC,CAAA,oBAAD,GAAwB,EANxB,CAAA;AAAA,IAQA,IAAC,CAAA,gBAAD,GAAoB,EARpB,CAAA;AAAA,IAUA,IAAC,CAAA,kBAAD,GAAsB,EAVtB,CAFW;EAAA,CAAb;;AAAA,sBAkBA,UAAA,GAAY,SAAC,IAAD,GAAA;AACV,IAAA,IAAG,IAAC,CAAA,SAAJ;aACE,IAAK,CAAA,CAAA,CAAE,CAAC,KAAR,CAAc,IAAd,EAAoB,IAAK,SAAzB,EADF;KAAA,MAAA;aAGE,IAAC,CAAA,mBAAmB,CAAC,IAArB,CAA0B,IAA1B,EAHF;KADU;EAAA,CAlBZ,CAAA;;AAAA,sBA4BA,aAAA,GAAe,SAAC,CAAD,GAAA;WACb,IAAC,CAAA,gBAAgB,CAAC,IAAlB,CAAuB,CAAvB,EADa;EAAA,CA5Bf,CAAA;;AAAA,sBAoCA,SAAA,GAAW,SAAC,KAAD,EAAQ,OAAR,GAAA;WACT,IAAC,CAAA,UAAD,CAAY,CAAC,KAAD,EAAQ,KAAR,EAAe,OAAf,CAAZ,EADS;EAAA,CApCX,CAAA;;AAAA,sBA4CA,OAAA,GAAS,SAAC,IAAD,EAAO,OAAP,GAAA;WACP,IAAC,CAAA,UAAD,CAAY,CAAC,KAAD,EAAQ,IAAR,EAAc,OAAd,CAAZ,EADO;EAAA,CA5CT,CAAA;;AAAA,sBAmDA,SAAA,GAAW,SAAC,OAAD,GAAA;WACT,IAAC,CAAA,UAAD,CAAY;MAAC,CAAA,SAAA,KAAA,GAAA;eAAA,SAAA,GAAA;AACX,cAAA,4BAAA;AAAA;AAAA;eAAA,cAAA;gCAAA;AACE,0BAAA,KAAC,CAAA,KAAD,CAAO,MAAP,EAAe,OAAf,EAAA,CADF;AAAA;0BADW;QAAA,EAAA;MAAA,CAAA,CAAA,CAAA,IAAA,CAAD;KAAZ,EADS;EAAA,CAnDX,CAAA;;AAAA,sBAmEA,WAAA,GAAa,SAAA,GAAA;AACX,QAAA,qBAAA;AAAA;SAAS,gGAAT,GAAA;AACE,oBAAA,IAAC,CAAA,kBAAkB,CAAC,OAApB,CAA4B,SAAU,CAAA,CAAA,CAAtC,EAAA,CADF;AAAA;oBADW;EAAA,CAnEb,CAAA;;mBAAA;;IAFF,CAAA;;AAAA,MA2EM,CAAC,OAAP,GAAiB,SA3EjB,CAAA;;;;;ACDA,IAAA,0BAAA;EAAA;;iSAAA;;AAAA,SAAA,GAAY,OAAA,CAAQ,cAAR,CAAZ,CAAA;;AAAA,MAEM,CAAC,eAAP,GAA+B;AAE7B,oCAAA,CAAA;;AAAa,EAAA,yBAAE,EAAF,EAAM,OAAN,GAAA;AACX,QAAA,IAAA;AAAA,IADY,IAAC,CAAA,KAAA,EACb,CAAA;AAAA,2DAAA,CAAA;AAAA,IAAA,+CAAA,CAAA,CAAA;AAAA,IACA,IAAA,GAAO,IADP,CAAA;AAAA,IAIA,IAAC,CAAA,kBAAkB,CAAC,IAApB,CAAyB,SAAA,GAAA;AACvB,UAAA,mBAAA;AAAA,MAAA,KAAA;;AAAQ;AAAA;aAAA,cAAA;8BAAA;AACN,wBAAA,OAAA,CADM;AAAA;;UAAR,CAAA;aAEA,MAHuB;IAAA,CAAzB,CAJA,CAAA;AAAA,IASA,IAAC,CAAA,kBAAkB,CAAC,IAApB,CAAyB,SAAC,KAAD,GAAA;AACvB,UAAA,gBAAA;AAAA,WAAA,4CAAA;2BAAA;AACI,QAAA,IAAI,CAAC,IAAL,CAAU,MAAV,CAAA,CADJ;AAAA,OAAA;aAEA,KAHuB;IAAA,CAAzB,CATA,CAAA;AAAA,IAcA,IAAC,CAAA,IAAD,GAAY,IAAA,IAAA,CAAK,IAAC,CAAA,EAAN,EAAU,OAAV,CAdZ,CAAA;AAAA,IAgBA,IAAC,CAAA,IAAI,CAAC,EAAN,CAAS,OAAT,EAAkB,SAAC,GAAD,GAAA;AAChB,YAAU,IAAA,KAAA,CAAO,oBAAA,GAAoB,GAA3B,CAAV,CADgB;IAAA,CAAlB,CAhBA,CAAA;AAAA,IAkBA,IAAC,CAAA,IAAI,CAAC,EAAN,CAAS,cAAT,EAAyB,SAAA,GAAA;AACvB,YAAU,IAAA,KAAA,CAAM,0HAAN,CAAV,CADuB;IAAA,CAAzB,CAlBA,CAAA;AAAA,IAoBA,IAAC,CAAA,IAAI,CAAC,EAAN,CAAS,YAAT,EAAuB,SAAA,GAAA;aACrB,IAAI,CAAC,IAAI,CAAC,SAAV,CAAA,EADqB;IAAA,CAAvB,CApBA,CAAA;AAAA,IAsBA,IAAC,CAAA,IAAI,CAAC,EAAN,CAAS,YAAT,EAAuB,IAAC,CAAA,cAAxB,CAtBA,CADW;EAAA,CAAb;;AAAA,4BA6BA,IAAA,GAAM,SAAC,MAAD,GAAA;AACJ,QAAA,IAAA;AAAA,IAAA,IAAO,2CAAJ,IAA2C,kCAA3C,IAAqE,MAAA,KAAY,IAAC,CAAA,EAArF;AACE,MAAA,IAAA,GAAO,IAAC,CAAA,IAAI,CAAC,OAAN,CAAc,MAAd,EAAsB;AAAA,QAAC,QAAA,EAAU,IAAX;OAAtB,CAAP,CAAA;AAAA,MACA,IAAC,CAAA,oBAAqB,CAAA,MAAA,CAAtB,GAAgC,IADhC,CAAA;AAAA,MAEA,IAAC,CAAA,cAAD,CAAgB,IAAhB,CAFA,CAAA;aAGA,KAJF;KAAA,MAAA;aAME,MANF;KADI;EAAA,CA7BN,CAAA;;AAAA,4BA+CA,KAAA,GAAO,SAAC,MAAD,EAAS,OAAT,GAAA;AACL,QAAA,6BAAA;AAAA,IAAA,IAAG,MAAM,CAAC,WAAP,KAAsB,EAAE,CAAC,WAA5B;AAGE,MAAA,MAAA,GAAS,EAAT,CAAA;AACA,WAAA,6CAAA;0BAAA;AACE;AACE,UAAA,IAAC,CAAA,UAAW,CAAA,IAAA,CAAK,CAAC,IAAlB,CAAuB,OAAvB,CAAA,CADF;SAAA,cAAA;AAGE,UADI,cACJ,CAAA;AAAA,UAAA,MAAM,CAAC,IAAP,CAAY,KAAA,GAAM,EAAlB,CAAA,CAHF;SADF;AAAA,OADA;AAMA,MAAA,IAAG,MAAM,CAAC,MAAP,GAAgB,CAAnB;AACE,cAAU,IAAA,KAAA,CAAM,MAAN,CAAV,CADF;OATF;KAAA,MAAA;aAYE,IAAC,CAAA,WAAY,CAAA,MAAA,CAAO,CAAC,IAArB,CAA0B,OAA1B,EAZF;KADK;EAAA,CA/CP,CAAA;;AAAA,4BAkEA,cAAA,GAAgB,SAAC,IAAD,GAAA;WACd,IAAI,CAAC,EAAL,CAAQ,MAAR,EAAgB,CAAA,SAAA,KAAA,GAAA;aAAA,SAAA,GAAA;AACd,YAAA,oBAAA;AAAA,QAAA,IAAA,GAAO,KAAP,CAAA;AAAA,QACA,IAAI,CAAC,IAAL,CAAU,IAAI,CAAC,kBAAmB,CAAA,CAAA,CAAxB,CAAA,CAAV,CADA,CAAA;AAAA,QAEA,cAAA,GAAiB,CAFjB,CAAA;eAGA,IAAI,CAAC,EAAL,CAAQ,MAAR,EAAgB,SAAC,IAAD,GAAA;AACd,cAAA,4DAAA;AAAA,UAAA,OAAO,CAAC,GAAR,CAAa,gBAAA,GAAe,CAAC,IAAI,CAAC,SAAL,CAAe,IAAf,CAAD,CAA5B,CAAA,CAAA;AACA,UAAA,IAAG,cAAA,GAAiB,IAAI,CAAC,kBAAkB,CAAC,MAA5C;mBACE,IAAI,CAAC,IAAL,CAAU,IAAI,CAAC,kBAAmB,CAAA,cAAA,EAAA,CAAiB,CAAC,IAA1C,CAA+C,IAA/C,EAAqD,IAArD,CAAV,EADF;WAAA,MAEK,IAAG,cAAA,KAAkB,IAAI,CAAC,kBAAkB,CAAC,MAA7C;AAEH,YAAA,cAAA,EAAA,CAAA;AAAA,YAEA,MAAA,CAAA,IAAW,CAAC,oBAAqB,CAAA,IAAI,CAAC,IAAL,CAFjC,CAAA;AAAA,YAGA,IAAI,CAAC,WAAY,CAAA,IAAI,CAAC,IAAL,CAAjB,GAA8B,IAH9B,CAAA;AAAA,YAKA,IAAI,CAAC,EAAL,CAAQ,OAAR,EAAiB,SAAA,GAAA;qBACf,MAAA,CAAA,IAAW,CAAC,WAAY,CAAA,IAAI,CAAC,IAAL,EADT;YAAA,CAAjB,CALA,CAAA;AAAA,YAQA,OAAA,GAAU,SAAC,EAAD,GAAA;AACR,kBAAA,CAAA;AAAA,mBAAA,OAAA,GAAA;AACE,uBAAO,KAAP,CADF;AAAA,eAAA;AAEA,qBAAO,IAAP,CAHQ;YAAA,CARV,CAAA;AAYA,YAAA,IAAG,OAAA,CAAQ,IAAI,CAAC,oBAAb,CAAH;AAGE,cAAA,IAAI,CAAC,SAAL,GAAiB,IAAjB,CAAA;AACA;AAAA,mBAAA,2CAAA;gCAAA;AACE,gBAAA,IAAK,CAAA,CAAA,CAAE,CAAC,KAAR,CAAc,IAAd,EAAoB,IAAK,SAAzB,CAAA,CADF;AAAA,eADA;qBAGA,IAAI,CAAC,mBAAL,GAA2B,GAN7B;aAdG;WAAA,MAAA;AAwBH;AAAA;iBAAA,8CAAA;4BAAA;AACE,4BAAA,CAAA,CAAE,IAAI,CAAC,IAAP,EAAa,IAAb,EAAA,CADF;AAAA;4BAxBG;WAJS;QAAA,CAAhB,EAJc;MAAA,EAAA;IAAA,CAAA,CAAA,CAAA,IAAA,CAAhB,EADc;EAAA,CAlEhB,CAAA;;yBAAA;;GAFqD,UAFvD,CAAA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error(\"Cannot find module '\"+o+\"'\")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\nclass Connector\n  \n  constructor: ()->\n    # is set to true when this is synced with all other connections\n    @is_synced = false\n    # compute all of these functions when all connections are synced.\n    @compute_when_synced = []\n    # Peerjs Connections: key: conn-id, value: conn\n    @connections = {}\n    # Connections, that have been initialized, but have not been (fully) synced yet.\n    @unsynced_connections = {}\n    # List of functions that shall process incoming data\n    @receive_handlers = []\n    # A list of functions that are executed (left to right) when syncing with a peer. \n    @sync_process_order = []\n    \n  #\n  # Execute a function _when_ we are connected. If not connected, wait until connected.\n  # @param f {Function} Will be executed on the PeerJs-Connector context.\n  #\n  whenSynced: (args)->\n    if @is_synced\n      args[0].apply this, args[1..]\n    else\n      @compute_when_synced.push args \n  \n  #\n  # Execute an function _when_ a message is received.\n  # @param f {Function} Will be executed on the PeerJs-Connector context. f will be called with (sender_id, broadcast {true|false}, message).\n  #\n  whenReceiving: (f)->\n    @receive_handlers.push f\n  \n  #\n  # Send a message to a (sub)-set of all connected peers.\n  # @param peers {Array<connection_ids>} A set of ids.\n  # @param message {Object} The message to send.\n  #\n  multicast: (peers, message)->\n    @whenSynced [_send, peers, message]\n  \n  #\n  # Send a message to one of the connected peers.\n  # @param peers {connection_id} A connection id.\n  # @param message {Object} The message to send.\n  #\n  unicast: (peer, message)->\n    @whenSynced [_send, peer, message]\n  \n  # \n  # Broadcast a message to all connected peers.\n  # @param message {Object} The message to broadcast.\n  # \n  broadcast: (message)->\n    @whenSynced [()=>\n      for peerid,peer of @connections\n        @_send peerid, message]\n \n  #\n  # Define how you want to handle the sync process of two users.\n  # This is a synchronous handshake. Every user will perform exactly the same actions at the same time. E.g.\n  # @example\n  #   whenSyncing(function(){ // first call must not have parameters!\n  #       return this.id; // Send the id of this connector.\n  #   },function(peerid){ // you receive the peerid of the other connections.\n  #       // you can do something with the peerid\n  #       // return \"you are my friend\"; // you could send another massage.\n  #   }); // this is the end of the sync process.\n  #\n  whenSyncing: ()->\n    for i in [(arguments.length-1)..0]\n      @sync_process_order.unshift arguments[i]\n\n\n\nmodule.exports = Connector\n","Connector = require '../connector'\n      \nwindow.PeerJsConnector = class PeerJsConnector extends Connector\n  \n  constructor: (@id, options)->\n    super()\n    that = this\n    # The following two functions should be performed at the end of the syncing process.\n    # In peerjs all connection ids must be send. \n    @sync_process_order.push ()->\n      peers = for peerid,conn of that.connections \n        peerid\n      peers \n    # Then connect to the connection ids. \n    @sync_process_order.push (peers)->\n      for peerid in peers \n          that.join peerid\n      true \n    # Create the Peerjs instance\n    @conn = new Peer @id, options\n    # TODO: improve error handling, what happens if disconnected? provide feedback\n    @conn.on 'error', (err)->\n      throw new Error \"Peerjs connector: #{err}\"\n    @conn.on 'disconnected', ()->\n      throw new Error \"Peerjs connector disconnected from signalling server. Cannot accept new connections. Not fatal, but not so good either..\"\n    @conn.on 'disconnect', ()->\n      that.conn.reconnect()\n    @conn.on 'connection', @_addConnection\n  \n  #\n  # Join a communication room. In case of peerjs, you just have to join to one other client. This connector will join to the other peers automatically.\n  # @param id {String} The connection id of another client.\n  #\n  join: (peerid)->\n    if not @unsynced_connections[peerid]? and not @connections[peerid]? and peerid isnt @id\n      peer = @conn.connect peerid, {reliable: true} \n      @unsynced_connections[peerid] = peer\n      @_addConnection peer\n      true\n    else\n      false\n  \n  #\n  # Send a message to a peer or set of peers. This is peerjs specific.\n  # @overload _send(peerid, message)\n  #   @param peerid {String} PeerJs connection id of _another_ peer\n  #   @param message {Object} Some object that shall be send\n  # @overload _send(peerids, message)\n  #   @param peerids {Array<String>} PeerJs connection ids of _other_ peers\n  #   @param message {Object} Some object that shall be send\n  #\n  _send: (peer_s, message)->\n    if peer_s.constructor is [].constructor\n      # Throw errors _after_ the message has been send to all other peers. \n      # Just in case a connection is invalid.\n      errors = []\n      for peer in peer_s\n        try\n          @connection[peer].send message\n        catch error \n          errors.push(error+\"\")\n      if errors.length > 0\n        throw new Error errors \n    else\n      @connections[peer_s].send message\n    \n  #\n  # @private\n  # This is a helper function that is only related to the peerjs connector. \n  # Connect to another peer.\n  _addConnection: (peer)=>\n    peer.on 'open', ()=>\n      that = @\n      peer.send that.sync_process_order[0]()\n      current_sync_i = 1\n      peer.on 'data', (data)->\n        console.log(\"receive data: #{JSON.stringify data}\")\n        if current_sync_i < that.sync_process_order.length\n          peer.send that.sync_process_order[current_sync_i++].call that, data\n        else if current_sync_i is that.sync_process_order.length\n          # All sync functions have been called. Increment current_sync_i one last time\n          current_sync_i++\n          # add it to the connections object\n          delete that.unsynced_connections[peer.peer]\n          that.connections[peer.peer] = peer\n          # when the conn closes, delete it from the connections object\n          peer.on 'close', ()->\n            delete that.connections[peer.peer]\n          # helper fkt. true iff os is an object that does not hold enumerable properties\n          isEmpty = (os)->\n            for o of os\n              return false\n            return true\n          if isEmpty(that.unsynced_connections)\n            # there are no unsynced connections. we are now synced. \n            # therefore execute all fkts in this.compute_when_synced\n            that.is_synced = true\n            for comp in that.compute_when_synced\n              comp[0].apply that, comp[1..]\n            that.compute_when_synced = []\n        else\n          # you received a new message, that is not a sync message.\n          # notify the receive_handlers\n          for f in that.receive_handlers \n            f peer.peer, data\n\n\n      "]} diff --git a/bower_components/connector/peerjs-connector/peerjs-connector.min.js b/bower_components/connector/peerjs-connector/peerjs-connector.min.js new file mode 100644 index 00000000..e5d89059 --- /dev/null +++ b/bower_components/connector/peerjs-connector/peerjs-connector.min.js @@ -0,0 +1 @@ +!function n(e,t,r){function o(i,s){if(!t[i]){if(!e[i]){var u="function"==typeof require&&require;if(!s&&u)return u(i,!0);if(c)return c(i,!0);throw new Error("Cannot find module '"+i+"'")}var h=t[i]={exports:{}};e[i][0].call(h.exports,function(n){var t=e[i][1][n];return o(t?t:n)},h,h.exports,n,e,t,r)}return t[i].exports}for(var c="function"==typeof require&&require,i=0;i=t?0>=e:e>=0;n=0>=t?++e:--e)r.push(this.sync_process_order.unshift(arguments[n]));return r},n}(),e.exports=t},{}],2:[function(n){var e,t,r=function(n,e){return function(){return n.apply(e,arguments)}},o={}.hasOwnProperty,c=function(n,e){function t(){this.constructor=n}for(var r in e)o.call(e,r)&&(n[r]=e[r]);return t.prototype=e.prototype,n.prototype=new t,n.__super__=e.prototype,n};e=n("../connector"),window.PeerJsConnector=t=function(n){function e(n,t){var o;this.id=n,this._addConnection=r(this._addConnection,this),e.__super__.constructor.call(this),o=this,this.sync_process_order.push(function(){var n,e,t;return t=function(){var t,r;t=o.connections,r=[];for(e in t)n=t[e],r.push(e);return r}()}),this.sync_process_order.push(function(n){var e,t,r;for(t=0,r=n.length;r>t;t++)e=n[t],o.join(e);return!0}),this.conn=new Peer(this.id,t),this.conn.on("error",function(n){throw new Error("Peerjs connector: "+n)}),this.conn.on("disconnected",function(){throw new Error("Peerjs connector disconnected from signalling server. Cannot accept new connections. Not fatal, but not so good either..")}),this.conn.on("disconnect",function(){return o.conn.reconnect()}),this.conn.on("connection",this._addConnection)}return c(e,n),e.prototype.join=function(n){var e;return null==this.unsynced_connections[n]&&null==this.connections[n]&&n!==this.id?(e=this.conn.connect(n,{reliable:!0}),this.unsynced_connections[n]=e,this._addConnection(e),!0):!1},e.prototype._send=function(n,e){var t,r,o,c,i;if(n.constructor!==[].constructor)return this.connections[n].send(e);for(r=[],c=0,i=n.length;i>c;c++){o=n[c];try{this.connection[o].send(e)}catch(s){t=s,r.push(t+"")}}if(r.length>0)throw new Error(r)},e.prototype._addConnection=function(n){return n.on("open",function(e){return function(){var t,r;return r=e,n.send(r.sync_process_order[0]()),t=1,n.on("data",function(e){var o,c,i,s,u,h,p,f,d,a;if(console.log("receive data: "+JSON.stringify(e)),tu;u++)c=d[u],a.push(c(n.peer,e));return a}if(t++,delete r.unsynced_connections[n.peer],r.connections[n.peer]=n,n.on("close",function(){return delete r.connections[n.peer]}),(i=function(n){var e;for(e in n)return!1;return!0})(r.unsynced_connections)){for(r.is_synced=!0,f=r.compute_when_synced,s=0,h=f.length;h>s;s++)o=f[s],o[0].apply(r,o.slice(1));return r.compute_when_synced=[]}})}}(this))},e}(e)},{"../connector":1}]},{},[2]); \ No newline at end of file diff --git a/bower_components/connector/test-connector/test-connector.js b/bower_components/connector/test-connector/test-connector.js new file mode 100644 index 00000000..dedbfa61 --- /dev/null +++ b/bower_components/connector/test-connector/test-connector.js @@ -0,0 +1,1617 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o= 0; i = _ref <= 0 ? ++_i : --_i) { + _results.push(this.sync_process_order.unshift(arguments[i])); + } + return _results; + }; + + return Connector; + +})(); + +module.exports = Connector; + + + +},{}],2:[function(require,module,exports){ +var Connector, TestConnector, _, + __hasProp = {}.hasOwnProperty, + __extends = function(child, parent) { for (var key in parent) { if (__hasProp.call(parent, key)) child[key] = parent[key]; } function ctor() { this.constructor = child; } ctor.prototype = parent.prototype; child.prototype = new ctor(); child.__super__ = parent.prototype; return child; }; + +_ = require("underscore"); + +Connector = require('../connector'); + +TestConnector = (function(_super) { + __extends(TestConnector, _super); + + function TestConnector(id) { + this.id = id; + TestConnector.__super__.constructor.call(this); + this.execution_order = []; + this.receive_buffer = {}; + this.connections = {}; + this.whenReceiving((function(_this) { + return function(user, message) { + return _this.execution_order.push(message); + }; + })(this)); + } + + TestConnector.prototype.join = function(conn) { + var c, cid, comp, _i, _len, _ref, _ref1, _results; + this._addConnection(conn.id, conn); + _ref = conn.connections; + for (cid in _ref) { + c = _ref[cid]; + this._addConnection(cid, c); + } + this.is_synced = true; + _ref1 = this.compute_when_synced; + _results = []; + for (_i = 0, _len = _ref1.length; _i < _len; _i++) { + comp = _ref1[_i]; + _results.push(comp[0].apply(this, comp.slice(1))); + } + return _results; + }; + + TestConnector.prototype._addConnection = function(id, user_connector) { + var data, data_, i, user_data, _i, _ref; + if (this.connections[id] == null) { + data = null; + user_data = null; + for (i = _i = 0, _ref = this.sync_process_order.length; 0 <= _ref ? _i < _ref : _i > _ref; i = 0 <= _ref ? ++_i : --_i) { + data_ = this.sync_process_order[i].call(this, user_data); + user_data = user_connector.sync_process_order[0].call(user_connector, data); + data = data_; + } + this.connections[id] = user_connector; + return user_connector.connections[this.id] = this; + } + }; + + TestConnector.prototype.getOpsInExecutionOrder = function() { + return this.execution_order; + }; + + TestConnector.prototype._send = function(uid, message) { + var rb, _name; + rb = this.connections[uid].receive_buffer; + if (rb[_name = this.id] == null) { + rb[_name] = []; + } + return rb[this.id].push(message); + }; + + TestConnector.prototype.flushOne = function(uid) { + var f, message, _i, _len, _ref, _ref1, _results; + if (((_ref = this.receive_buffer[uid]) != null ? _ref.length : void 0) > 0) { + message = this.receive_buffer[uid].shift(); + _ref1 = this.receive_handlers; + _results = []; + for (_i = 0, _len = _ref1.length; _i < _len; _i++) { + f = _ref1[_i]; + _results.push(f(uid, message)); + } + return _results; + } + }; + + TestConnector.prototype.flushOneRandom = function() { + var c, cid, connlist; + connlist = (function() { + var _ref, _results; + _ref = this.receive_buffer; + _results = []; + for (cid in _ref) { + c = _ref[cid]; + _results.push(cid); + } + return _results; + }).call(this); + return this.flushOne(connlist[_.random(0, connlist.length - 1)]); + }; + + TestConnector.prototype.flushAll = function() { + var f, message, messages, n, _i, _j, _len, _len1, _ref, _ref1; + _ref = this.receive_buffer; + for (n in _ref) { + messages = _ref[n]; + for (_i = 0, _len = messages.length; _i < _len; _i++) { + message = messages[_i]; + _ref1 = this.receive_handlers; + for (_j = 0, _len1 = _ref1.length; _j < _len1; _j++) { + f = _ref1[_j]; + f(n, message); + } + } + } + return this.receive_buffer = {}; + }; + + return TestConnector; + +})(Connector); + +if (typeof window !== "undefined" && window !== null) { + window.TestConnector = TestConnector; +} + +if (typeof module !== "undefined" && module !== null) { + module.exports = TestConnector; +} + + + +},{"../connector":1,"underscore":3}],3:[function(require,module,exports){ +// Underscore.js 1.7.0 +// http://underscorejs.org +// (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors +// Underscore may be freely distributed under the MIT license. + +(function() { + + // Baseline setup + // -------------- + + // Establish the root object, `window` in the browser, or `exports` on the server. + var root = this; + + // Save the previous value of the `_` variable. + var previousUnderscore = root._; + + // Save bytes in the minified (but not gzipped) version: + var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype; + + // Create quick reference variables for speed access to core prototypes. + var + push = ArrayProto.push, + slice = ArrayProto.slice, + concat = ArrayProto.concat, + toString = ObjProto.toString, + hasOwnProperty = ObjProto.hasOwnProperty; + + // All **ECMAScript 5** native function implementations that we hope to use + // are declared here. + var + nativeIsArray = Array.isArray, + nativeKeys = Object.keys, + nativeBind = FuncProto.bind; + + // Create a safe reference to the Underscore object for use below. + var _ = function(obj) { + if (obj instanceof _) return obj; + if (!(this instanceof _)) return new _(obj); + this._wrapped = obj; + }; + + // Export the Underscore object for **Node.js**, with + // backwards-compatibility for the old `require()` API. If we're in + // the browser, add `_` as a global object. + if (typeof exports !== 'undefined') { + if (typeof module !== 'undefined' && module.exports) { + exports = module.exports = _; + } + exports._ = _; + } else { + root._ = _; + } + + // Current version. + _.VERSION = '1.7.0'; + + // Internal function that returns an efficient (for current engines) version + // of the passed-in callback, to be repeatedly applied in other Underscore + // functions. + var createCallback = function(func, context, argCount) { + if (context === void 0) return func; + switch (argCount == null ? 3 : argCount) { + case 1: return function(value) { + return func.call(context, value); + }; + case 2: return function(value, other) { + return func.call(context, value, other); + }; + case 3: return function(value, index, collection) { + return func.call(context, value, index, collection); + }; + case 4: return function(accumulator, value, index, collection) { + return func.call(context, accumulator, value, index, collection); + }; + } + return function() { + return func.apply(context, arguments); + }; + }; + + // A mostly-internal function to generate callbacks that can be applied + // to each element in a collection, returning the desired result — either + // identity, an arbitrary callback, a property matcher, or a property accessor. + _.iteratee = function(value, context, argCount) { + if (value == null) return _.identity; + if (_.isFunction(value)) return createCallback(value, context, argCount); + if (_.isObject(value)) return _.matches(value); + return _.property(value); + }; + + // Collection Functions + // -------------------- + + // The cornerstone, an `each` implementation, aka `forEach`. + // Handles raw objects in addition to array-likes. Treats all + // sparse array-likes as if they were dense. + _.each = _.forEach = function(obj, iteratee, context) { + if (obj == null) return obj; + iteratee = createCallback(iteratee, context); + var i, length = obj.length; + if (length === +length) { + for (i = 0; i < length; i++) { + iteratee(obj[i], i, obj); + } + } else { + var keys = _.keys(obj); + for (i = 0, length = keys.length; i < length; i++) { + iteratee(obj[keys[i]], keys[i], obj); + } + } + return obj; + }; + + // Return the results of applying the iteratee to each element. + _.map = _.collect = function(obj, iteratee, context) { + if (obj == null) return []; + iteratee = _.iteratee(iteratee, context); + var keys = obj.length !== +obj.length && _.keys(obj), + length = (keys || obj).length, + results = Array(length), + currentKey; + for (var index = 0; index < length; index++) { + currentKey = keys ? keys[index] : index; + results[index] = iteratee(obj[currentKey], currentKey, obj); + } + return results; + }; + + var reduceError = 'Reduce of empty array with no initial value'; + + // **Reduce** builds up a single result from a list of values, aka `inject`, + // or `foldl`. + _.reduce = _.foldl = _.inject = function(obj, iteratee, memo, context) { + if (obj == null) obj = []; + iteratee = createCallback(iteratee, context, 4); + var keys = obj.length !== +obj.length && _.keys(obj), + length = (keys || obj).length, + index = 0, currentKey; + if (arguments.length < 3) { + if (!length) throw new TypeError(reduceError); + memo = obj[keys ? keys[index++] : index++]; + } + for (; index < length; index++) { + currentKey = keys ? keys[index] : index; + memo = iteratee(memo, obj[currentKey], currentKey, obj); + } + return memo; + }; + + // The right-associative version of reduce, also known as `foldr`. + _.reduceRight = _.foldr = function(obj, iteratee, memo, context) { + if (obj == null) obj = []; + iteratee = createCallback(iteratee, context, 4); + var keys = obj.length !== + obj.length && _.keys(obj), + index = (keys || obj).length, + currentKey; + if (arguments.length < 3) { + if (!index) throw new TypeError(reduceError); + memo = obj[keys ? keys[--index] : --index]; + } + while (index--) { + currentKey = keys ? keys[index] : index; + memo = iteratee(memo, obj[currentKey], currentKey, obj); + } + return memo; + }; + + // Return the first value which passes a truth test. Aliased as `detect`. + _.find = _.detect = function(obj, predicate, context) { + var result; + predicate = _.iteratee(predicate, context); + _.some(obj, function(value, index, list) { + if (predicate(value, index, list)) { + result = value; + return true; + } + }); + return result; + }; + + // Return all the elements that pass a truth test. + // Aliased as `select`. + _.filter = _.select = function(obj, predicate, context) { + var results = []; + if (obj == null) return results; + predicate = _.iteratee(predicate, context); + _.each(obj, function(value, index, list) { + if (predicate(value, index, list)) results.push(value); + }); + return results; + }; + + // Return all the elements for which a truth test fails. + _.reject = function(obj, predicate, context) { + return _.filter(obj, _.negate(_.iteratee(predicate)), context); + }; + + // Determine whether all of the elements match a truth test. + // Aliased as `all`. + _.every = _.all = function(obj, predicate, context) { + if (obj == null) return true; + predicate = _.iteratee(predicate, context); + var keys = obj.length !== +obj.length && _.keys(obj), + length = (keys || obj).length, + index, currentKey; + for (index = 0; index < length; index++) { + currentKey = keys ? keys[index] : index; + if (!predicate(obj[currentKey], currentKey, obj)) return false; + } + return true; + }; + + // Determine if at least one element in the object matches a truth test. + // Aliased as `any`. + _.some = _.any = function(obj, predicate, context) { + if (obj == null) return false; + predicate = _.iteratee(predicate, context); + var keys = obj.length !== +obj.length && _.keys(obj), + length = (keys || obj).length, + index, currentKey; + for (index = 0; index < length; index++) { + currentKey = keys ? keys[index] : index; + if (predicate(obj[currentKey], currentKey, obj)) return true; + } + return false; + }; + + // Determine if the array or object contains a given value (using `===`). + // Aliased as `include`. + _.contains = _.include = function(obj, target) { + if (obj == null) return false; + if (obj.length !== +obj.length) obj = _.values(obj); + return _.indexOf(obj, target) >= 0; + }; + + // Invoke a method (with arguments) on every item in a collection. + _.invoke = function(obj, method) { + var args = slice.call(arguments, 2); + var isFunc = _.isFunction(method); + return _.map(obj, function(value) { + return (isFunc ? method : value[method]).apply(value, args); + }); + }; + + // Convenience version of a common use case of `map`: fetching a property. + _.pluck = function(obj, key) { + return _.map(obj, _.property(key)); + }; + + // Convenience version of a common use case of `filter`: selecting only objects + // containing specific `key:value` pairs. + _.where = function(obj, attrs) { + return _.filter(obj, _.matches(attrs)); + }; + + // Convenience version of a common use case of `find`: getting the first object + // containing specific `key:value` pairs. + _.findWhere = function(obj, attrs) { + return _.find(obj, _.matches(attrs)); + }; + + // Return the maximum element (or element-based computation). + _.max = function(obj, iteratee, context) { + var result = -Infinity, lastComputed = -Infinity, + value, computed; + if (iteratee == null && obj != null) { + obj = obj.length === +obj.length ? obj : _.values(obj); + for (var i = 0, length = obj.length; i < length; i++) { + value = obj[i]; + if (value > result) { + result = value; + } + } + } else { + iteratee = _.iteratee(iteratee, context); + _.each(obj, function(value, index, list) { + computed = iteratee(value, index, list); + if (computed > lastComputed || computed === -Infinity && result === -Infinity) { + result = value; + lastComputed = computed; + } + }); + } + return result; + }; + + // Return the minimum element (or element-based computation). + _.min = function(obj, iteratee, context) { + var result = Infinity, lastComputed = Infinity, + value, computed; + if (iteratee == null && obj != null) { + obj = obj.length === +obj.length ? obj : _.values(obj); + for (var i = 0, length = obj.length; i < length; i++) { + value = obj[i]; + if (value < result) { + result = value; + } + } + } else { + iteratee = _.iteratee(iteratee, context); + _.each(obj, function(value, index, list) { + computed = iteratee(value, index, list); + if (computed < lastComputed || computed === Infinity && result === Infinity) { + result = value; + lastComputed = computed; + } + }); + } + return result; + }; + + // Shuffle a collection, using the modern version of the + // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle). + _.shuffle = function(obj) { + var set = obj && obj.length === +obj.length ? obj : _.values(obj); + var length = set.length; + var shuffled = Array(length); + for (var index = 0, rand; index < length; index++) { + rand = _.random(0, index); + if (rand !== index) shuffled[index] = shuffled[rand]; + shuffled[rand] = set[index]; + } + return shuffled; + }; + + // Sample **n** random values from a collection. + // If **n** is not specified, returns a single random element. + // The internal `guard` argument allows it to work with `map`. + _.sample = function(obj, n, guard) { + if (n == null || guard) { + if (obj.length !== +obj.length) obj = _.values(obj); + return obj[_.random(obj.length - 1)]; + } + return _.shuffle(obj).slice(0, Math.max(0, n)); + }; + + // Sort the object's values by a criterion produced by an iteratee. + _.sortBy = function(obj, iteratee, context) { + iteratee = _.iteratee(iteratee, context); + return _.pluck(_.map(obj, function(value, index, list) { + return { + value: value, + index: index, + criteria: iteratee(value, index, list) + }; + }).sort(function(left, right) { + var a = left.criteria; + var b = right.criteria; + if (a !== b) { + if (a > b || a === void 0) return 1; + if (a < b || b === void 0) return -1; + } + return left.index - right.index; + }), 'value'); + }; + + // An internal function used for aggregate "group by" operations. + var group = function(behavior) { + return function(obj, iteratee, context) { + var result = {}; + iteratee = _.iteratee(iteratee, context); + _.each(obj, function(value, index) { + var key = iteratee(value, index, obj); + behavior(result, value, key); + }); + return result; + }; + }; + + // Groups the object's values by a criterion. Pass either a string attribute + // to group by, or a function that returns the criterion. + _.groupBy = group(function(result, value, key) { + if (_.has(result, key)) result[key].push(value); else result[key] = [value]; + }); + + // Indexes the object's values by a criterion, similar to `groupBy`, but for + // when you know that your index values will be unique. + _.indexBy = group(function(result, value, key) { + result[key] = value; + }); + + // Counts instances of an object that group by a certain criterion. Pass + // either a string attribute to count by, or a function that returns the + // criterion. + _.countBy = group(function(result, value, key) { + if (_.has(result, key)) result[key]++; else result[key] = 1; + }); + + // Use a comparator function to figure out the smallest index at which + // an object should be inserted so as to maintain order. Uses binary search. + _.sortedIndex = function(array, obj, iteratee, context) { + iteratee = _.iteratee(iteratee, context, 1); + var value = iteratee(obj); + var low = 0, high = array.length; + while (low < high) { + var mid = low + high >>> 1; + if (iteratee(array[mid]) < value) low = mid + 1; else high = mid; + } + return low; + }; + + // Safely create a real, live array from anything iterable. + _.toArray = function(obj) { + if (!obj) return []; + if (_.isArray(obj)) return slice.call(obj); + if (obj.length === +obj.length) return _.map(obj, _.identity); + return _.values(obj); + }; + + // Return the number of elements in an object. + _.size = function(obj) { + if (obj == null) return 0; + return obj.length === +obj.length ? obj.length : _.keys(obj).length; + }; + + // Split a collection into two arrays: one whose elements all satisfy the given + // predicate, and one whose elements all do not satisfy the predicate. + _.partition = function(obj, predicate, context) { + predicate = _.iteratee(predicate, context); + var pass = [], fail = []; + _.each(obj, function(value, key, obj) { + (predicate(value, key, obj) ? pass : fail).push(value); + }); + return [pass, fail]; + }; + + // Array Functions + // --------------- + + // Get the first element of an array. Passing **n** will return the first N + // values in the array. Aliased as `head` and `take`. The **guard** check + // allows it to work with `_.map`. + _.first = _.head = _.take = function(array, n, guard) { + if (array == null) return void 0; + if (n == null || guard) return array[0]; + if (n < 0) return []; + return slice.call(array, 0, n); + }; + + // Returns everything but the last entry of the array. Especially useful on + // the arguments object. Passing **n** will return all the values in + // the array, excluding the last N. The **guard** check allows it to work with + // `_.map`. + _.initial = function(array, n, guard) { + return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n))); + }; + + // Get the last element of an array. Passing **n** will return the last N + // values in the array. The **guard** check allows it to work with `_.map`. + _.last = function(array, n, guard) { + if (array == null) return void 0; + if (n == null || guard) return array[array.length - 1]; + return slice.call(array, Math.max(array.length - n, 0)); + }; + + // Returns everything but the first entry of the array. Aliased as `tail` and `drop`. + // Especially useful on the arguments object. Passing an **n** will return + // the rest N values in the array. The **guard** + // check allows it to work with `_.map`. + _.rest = _.tail = _.drop = function(array, n, guard) { + return slice.call(array, n == null || guard ? 1 : n); + }; + + // Trim out all falsy values from an array. + _.compact = function(array) { + return _.filter(array, _.identity); + }; + + // Internal implementation of a recursive `flatten` function. + var flatten = function(input, shallow, strict, output) { + if (shallow && _.every(input, _.isArray)) { + return concat.apply(output, input); + } + for (var i = 0, length = input.length; i < length; i++) { + var value = input[i]; + if (!_.isArray(value) && !_.isArguments(value)) { + if (!strict) output.push(value); + } else if (shallow) { + push.apply(output, value); + } else { + flatten(value, shallow, strict, output); + } + } + return output; + }; + + // Flatten out an array, either recursively (by default), or just one level. + _.flatten = function(array, shallow) { + return flatten(array, shallow, false, []); + }; + + // Return a version of the array that does not contain the specified value(s). + _.without = function(array) { + return _.difference(array, slice.call(arguments, 1)); + }; + + // Produce a duplicate-free version of the array. If the array has already + // been sorted, you have the option of using a faster algorithm. + // Aliased as `unique`. + _.uniq = _.unique = function(array, isSorted, iteratee, context) { + if (array == null) return []; + if (!_.isBoolean(isSorted)) { + context = iteratee; + iteratee = isSorted; + isSorted = false; + } + if (iteratee != null) iteratee = _.iteratee(iteratee, context); + var result = []; + var seen = []; + for (var i = 0, length = array.length; i < length; i++) { + var value = array[i]; + if (isSorted) { + if (!i || seen !== value) result.push(value); + seen = value; + } else if (iteratee) { + var computed = iteratee(value, i, array); + if (_.indexOf(seen, computed) < 0) { + seen.push(computed); + result.push(value); + } + } else if (_.indexOf(result, value) < 0) { + result.push(value); + } + } + return result; + }; + + // Produce an array that contains the union: each distinct element from all of + // the passed-in arrays. + _.union = function() { + return _.uniq(flatten(arguments, true, true, [])); + }; + + // Produce an array that contains every item shared between all the + // passed-in arrays. + _.intersection = function(array) { + if (array == null) return []; + var result = []; + var argsLength = arguments.length; + for (var i = 0, length = array.length; i < length; i++) { + var item = array[i]; + if (_.contains(result, item)) continue; + for (var j = 1; j < argsLength; j++) { + if (!_.contains(arguments[j], item)) break; + } + if (j === argsLength) result.push(item); + } + return result; + }; + + // Take the difference between one array and a number of other arrays. + // Only the elements present in just the first array will remain. + _.difference = function(array) { + var rest = flatten(slice.call(arguments, 1), true, true, []); + return _.filter(array, function(value){ + return !_.contains(rest, value); + }); + }; + + // Zip together multiple lists into a single array -- elements that share + // an index go together. + _.zip = function(array) { + if (array == null) return []; + var length = _.max(arguments, 'length').length; + var results = Array(length); + for (var i = 0; i < length; i++) { + results[i] = _.pluck(arguments, i); + } + return results; + }; + + // Converts lists into objects. Pass either a single array of `[key, value]` + // pairs, or two parallel arrays of the same length -- one of keys, and one of + // the corresponding values. + _.object = function(list, values) { + if (list == null) return {}; + var result = {}; + for (var i = 0, length = list.length; i < length; i++) { + if (values) { + result[list[i]] = values[i]; + } else { + result[list[i][0]] = list[i][1]; + } + } + return result; + }; + + // Return the position of the first occurrence of an item in an array, + // or -1 if the item is not included in the array. + // If the array is large and already in sort order, pass `true` + // for **isSorted** to use binary search. + _.indexOf = function(array, item, isSorted) { + if (array == null) return -1; + var i = 0, length = array.length; + if (isSorted) { + if (typeof isSorted == 'number') { + i = isSorted < 0 ? Math.max(0, length + isSorted) : isSorted; + } else { + i = _.sortedIndex(array, item); + return array[i] === item ? i : -1; + } + } + for (; i < length; i++) if (array[i] === item) return i; + return -1; + }; + + _.lastIndexOf = function(array, item, from) { + if (array == null) return -1; + var idx = array.length; + if (typeof from == 'number') { + idx = from < 0 ? idx + from + 1 : Math.min(idx, from + 1); + } + while (--idx >= 0) if (array[idx] === item) return idx; + return -1; + }; + + // Generate an integer Array containing an arithmetic progression. A port of + // the native Python `range()` function. See + // [the Python documentation](http://docs.python.org/library/functions.html#range). + _.range = function(start, stop, step) { + if (arguments.length <= 1) { + stop = start || 0; + start = 0; + } + step = step || 1; + + var length = Math.max(Math.ceil((stop - start) / step), 0); + var range = Array(length); + + for (var idx = 0; idx < length; idx++, start += step) { + range[idx] = start; + } + + return range; + }; + + // Function (ahem) Functions + // ------------------ + + // Reusable constructor function for prototype setting. + var Ctor = function(){}; + + // Create a function bound to a given object (assigning `this`, and arguments, + // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if + // available. + _.bind = function(func, context) { + var args, bound; + if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1)); + if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function'); + args = slice.call(arguments, 2); + bound = function() { + if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments))); + Ctor.prototype = func.prototype; + var self = new Ctor; + Ctor.prototype = null; + var result = func.apply(self, args.concat(slice.call(arguments))); + if (_.isObject(result)) return result; + return self; + }; + return bound; + }; + + // Partially apply a function by creating a version that has had some of its + // arguments pre-filled, without changing its dynamic `this` context. _ acts + // as a placeholder, allowing any combination of arguments to be pre-filled. + _.partial = function(func) { + var boundArgs = slice.call(arguments, 1); + return function() { + var position = 0; + var args = boundArgs.slice(); + for (var i = 0, length = args.length; i < length; i++) { + if (args[i] === _) args[i] = arguments[position++]; + } + while (position < arguments.length) args.push(arguments[position++]); + return func.apply(this, args); + }; + }; + + // Bind a number of an object's methods to that object. Remaining arguments + // are the method names to be bound. Useful for ensuring that all callbacks + // defined on an object belong to it. + _.bindAll = function(obj) { + var i, length = arguments.length, key; + if (length <= 1) throw new Error('bindAll must be passed function names'); + for (i = 1; i < length; i++) { + key = arguments[i]; + obj[key] = _.bind(obj[key], obj); + } + return obj; + }; + + // Memoize an expensive function by storing its results. + _.memoize = function(func, hasher) { + var memoize = function(key) { + var cache = memoize.cache; + var address = hasher ? hasher.apply(this, arguments) : key; + if (!_.has(cache, address)) cache[address] = func.apply(this, arguments); + return cache[address]; + }; + memoize.cache = {}; + return memoize; + }; + + // Delays a function for the given number of milliseconds, and then calls + // it with the arguments supplied. + _.delay = function(func, wait) { + var args = slice.call(arguments, 2); + return setTimeout(function(){ + return func.apply(null, args); + }, wait); + }; + + // Defers a function, scheduling it to run after the current call stack has + // cleared. + _.defer = function(func) { + return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1))); + }; + + // Returns a function, that, when invoked, will only be triggered at most once + // during a given window of time. Normally, the throttled function will run + // as much as it can, without ever going more than once per `wait` duration; + // but if you'd like to disable the execution on the leading edge, pass + // `{leading: false}`. To disable execution on the trailing edge, ditto. + _.throttle = function(func, wait, options) { + var context, args, result; + var timeout = null; + var previous = 0; + if (!options) options = {}; + var later = function() { + previous = options.leading === false ? 0 : _.now(); + timeout = null; + result = func.apply(context, args); + if (!timeout) context = args = null; + }; + return function() { + var now = _.now(); + if (!previous && options.leading === false) previous = now; + var remaining = wait - (now - previous); + context = this; + args = arguments; + if (remaining <= 0 || remaining > wait) { + clearTimeout(timeout); + timeout = null; + previous = now; + result = func.apply(context, args); + if (!timeout) context = args = null; + } else if (!timeout && options.trailing !== false) { + timeout = setTimeout(later, remaining); + } + return result; + }; + }; + + // Returns a function, that, as long as it continues to be invoked, will not + // be triggered. The function will be called after it stops being called for + // N milliseconds. If `immediate` is passed, trigger the function on the + // leading edge, instead of the trailing. + _.debounce = function(func, wait, immediate) { + var timeout, args, context, timestamp, result; + + var later = function() { + var last = _.now() - timestamp; + + if (last < wait && last > 0) { + timeout = setTimeout(later, wait - last); + } else { + timeout = null; + if (!immediate) { + result = func.apply(context, args); + if (!timeout) context = args = null; + } + } + }; + + return function() { + context = this; + args = arguments; + timestamp = _.now(); + var callNow = immediate && !timeout; + if (!timeout) timeout = setTimeout(later, wait); + if (callNow) { + result = func.apply(context, args); + context = args = null; + } + + return result; + }; + }; + + // Returns the first function passed as an argument to the second, + // allowing you to adjust arguments, run code before and after, and + // conditionally execute the original function. + _.wrap = function(func, wrapper) { + return _.partial(wrapper, func); + }; + + // Returns a negated version of the passed-in predicate. + _.negate = function(predicate) { + return function() { + return !predicate.apply(this, arguments); + }; + }; + + // Returns a function that is the composition of a list of functions, each + // consuming the return value of the function that follows. + _.compose = function() { + var args = arguments; + var start = args.length - 1; + return function() { + var i = start; + var result = args[start].apply(this, arguments); + while (i--) result = args[i].call(this, result); + return result; + }; + }; + + // Returns a function that will only be executed after being called N times. + _.after = function(times, func) { + return function() { + if (--times < 1) { + return func.apply(this, arguments); + } + }; + }; + + // Returns a function that will only be executed before being called N times. + _.before = function(times, func) { + var memo; + return function() { + if (--times > 0) { + memo = func.apply(this, arguments); + } else { + func = null; + } + return memo; + }; + }; + + // Returns a function that will be executed at most one time, no matter how + // often you call it. Useful for lazy initialization. + _.once = _.partial(_.before, 2); + + // Object Functions + // ---------------- + + // Retrieve the names of an object's properties. + // Delegates to **ECMAScript 5**'s native `Object.keys` + _.keys = function(obj) { + if (!_.isObject(obj)) return []; + if (nativeKeys) return nativeKeys(obj); + var keys = []; + for (var key in obj) if (_.has(obj, key)) keys.push(key); + return keys; + }; + + // Retrieve the values of an object's properties. + _.values = function(obj) { + var keys = _.keys(obj); + var length = keys.length; + var values = Array(length); + for (var i = 0; i < length; i++) { + values[i] = obj[keys[i]]; + } + return values; + }; + + // Convert an object into a list of `[key, value]` pairs. + _.pairs = function(obj) { + var keys = _.keys(obj); + var length = keys.length; + var pairs = Array(length); + for (var i = 0; i < length; i++) { + pairs[i] = [keys[i], obj[keys[i]]]; + } + return pairs; + }; + + // Invert the keys and values of an object. The values must be serializable. + _.invert = function(obj) { + var result = {}; + var keys = _.keys(obj); + for (var i = 0, length = keys.length; i < length; i++) { + result[obj[keys[i]]] = keys[i]; + } + return result; + }; + + // Return a sorted list of the function names available on the object. + // Aliased as `methods` + _.functions = _.methods = function(obj) { + var names = []; + for (var key in obj) { + if (_.isFunction(obj[key])) names.push(key); + } + return names.sort(); + }; + + // Extend a given object with all the properties in passed-in object(s). + _.extend = function(obj) { + if (!_.isObject(obj)) return obj; + var source, prop; + for (var i = 1, length = arguments.length; i < length; i++) { + source = arguments[i]; + for (prop in source) { + if (hasOwnProperty.call(source, prop)) { + obj[prop] = source[prop]; + } + } + } + return obj; + }; + + // Return a copy of the object only containing the whitelisted properties. + _.pick = function(obj, iteratee, context) { + var result = {}, key; + if (obj == null) return result; + if (_.isFunction(iteratee)) { + iteratee = createCallback(iteratee, context); + for (key in obj) { + var value = obj[key]; + if (iteratee(value, key, obj)) result[key] = value; + } + } else { + var keys = concat.apply([], slice.call(arguments, 1)); + obj = new Object(obj); + for (var i = 0, length = keys.length; i < length; i++) { + key = keys[i]; + if (key in obj) result[key] = obj[key]; + } + } + return result; + }; + + // Return a copy of the object without the blacklisted properties. + _.omit = function(obj, iteratee, context) { + if (_.isFunction(iteratee)) { + iteratee = _.negate(iteratee); + } else { + var keys = _.map(concat.apply([], slice.call(arguments, 1)), String); + iteratee = function(value, key) { + return !_.contains(keys, key); + }; + } + return _.pick(obj, iteratee, context); + }; + + // Fill in a given object with default properties. + _.defaults = function(obj) { + if (!_.isObject(obj)) return obj; + for (var i = 1, length = arguments.length; i < length; i++) { + var source = arguments[i]; + for (var prop in source) { + if (obj[prop] === void 0) obj[prop] = source[prop]; + } + } + return obj; + }; + + // Create a (shallow-cloned) duplicate of an object. + _.clone = function(obj) { + if (!_.isObject(obj)) return obj; + return _.isArray(obj) ? obj.slice() : _.extend({}, obj); + }; + + // Invokes interceptor with the obj, and then returns obj. + // The primary purpose of this method is to "tap into" a method chain, in + // order to perform operations on intermediate results within the chain. + _.tap = function(obj, interceptor) { + interceptor(obj); + return obj; + }; + + // Internal recursive comparison function for `isEqual`. + var eq = function(a, b, aStack, bStack) { + // Identical objects are equal. `0 === -0`, but they aren't identical. + // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal). + if (a === b) return a !== 0 || 1 / a === 1 / b; + // A strict comparison is necessary because `null == undefined`. + if (a == null || b == null) return a === b; + // Unwrap any wrapped objects. + if (a instanceof _) a = a._wrapped; + if (b instanceof _) b = b._wrapped; + // Compare `[[Class]]` names. + var className = toString.call(a); + if (className !== toString.call(b)) return false; + switch (className) { + // Strings, numbers, regular expressions, dates, and booleans are compared by value. + case '[object RegExp]': + // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i') + case '[object String]': + // Primitives and their corresponding object wrappers are equivalent; thus, `"5"` is + // equivalent to `new String("5")`. + return '' + a === '' + b; + case '[object Number]': + // `NaN`s are equivalent, but non-reflexive. + // Object(NaN) is equivalent to NaN + if (+a !== +a) return +b !== +b; + // An `egal` comparison is performed for other numeric values. + return +a === 0 ? 1 / +a === 1 / b : +a === +b; + case '[object Date]': + case '[object Boolean]': + // Coerce dates and booleans to numeric primitive values. Dates are compared by their + // millisecond representations. Note that invalid dates with millisecond representations + // of `NaN` are not equivalent. + return +a === +b; + } + if (typeof a != 'object' || typeof b != 'object') return false; + // Assume equality for cyclic structures. The algorithm for detecting cyclic + // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`. + var length = aStack.length; + while (length--) { + // Linear search. Performance is inversely proportional to the number of + // unique nested structures. + if (aStack[length] === a) return bStack[length] === b; + } + // Objects with different constructors are not equivalent, but `Object`s + // from different frames are. + var aCtor = a.constructor, bCtor = b.constructor; + if ( + aCtor !== bCtor && + // Handle Object.create(x) cases + 'constructor' in a && 'constructor' in b && + !(_.isFunction(aCtor) && aCtor instanceof aCtor && + _.isFunction(bCtor) && bCtor instanceof bCtor) + ) { + return false; + } + // Add the first object to the stack of traversed objects. + aStack.push(a); + bStack.push(b); + var size, result; + // Recursively compare objects and arrays. + if (className === '[object Array]') { + // Compare array lengths to determine if a deep comparison is necessary. + size = a.length; + result = size === b.length; + if (result) { + // Deep compare the contents, ignoring non-numeric properties. + while (size--) { + if (!(result = eq(a[size], b[size], aStack, bStack))) break; + } + } + } else { + // Deep compare objects. + var keys = _.keys(a), key; + size = keys.length; + // Ensure that both objects contain the same number of properties before comparing deep equality. + result = _.keys(b).length === size; + if (result) { + while (size--) { + // Deep compare each member + key = keys[size]; + if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break; + } + } + } + // Remove the first object from the stack of traversed objects. + aStack.pop(); + bStack.pop(); + return result; + }; + + // Perform a deep comparison to check if two objects are equal. + _.isEqual = function(a, b) { + return eq(a, b, [], []); + }; + + // Is a given array, string, or object empty? + // An "empty" object has no enumerable own-properties. + _.isEmpty = function(obj) { + if (obj == null) return true; + if (_.isArray(obj) || _.isString(obj) || _.isArguments(obj)) return obj.length === 0; + for (var key in obj) if (_.has(obj, key)) return false; + return true; + }; + + // Is a given value a DOM element? + _.isElement = function(obj) { + return !!(obj && obj.nodeType === 1); + }; + + // Is a given value an array? + // Delegates to ECMA5's native Array.isArray + _.isArray = nativeIsArray || function(obj) { + return toString.call(obj) === '[object Array]'; + }; + + // Is a given variable an object? + _.isObject = function(obj) { + var type = typeof obj; + return type === 'function' || type === 'object' && !!obj; + }; + + // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp. + _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) { + _['is' + name] = function(obj) { + return toString.call(obj) === '[object ' + name + ']'; + }; + }); + + // Define a fallback version of the method in browsers (ahem, IE), where + // there isn't any inspectable "Arguments" type. + if (!_.isArguments(arguments)) { + _.isArguments = function(obj) { + return _.has(obj, 'callee'); + }; + } + + // Optimize `isFunction` if appropriate. Work around an IE 11 bug. + if (typeof /./ !== 'function') { + _.isFunction = function(obj) { + return typeof obj == 'function' || false; + }; + } + + // Is a given object a finite number? + _.isFinite = function(obj) { + return isFinite(obj) && !isNaN(parseFloat(obj)); + }; + + // Is the given value `NaN`? (NaN is the only number which does not equal itself). + _.isNaN = function(obj) { + return _.isNumber(obj) && obj !== +obj; + }; + + // Is a given value a boolean? + _.isBoolean = function(obj) { + return obj === true || obj === false || toString.call(obj) === '[object Boolean]'; + }; + + // Is a given value equal to null? + _.isNull = function(obj) { + return obj === null; + }; + + // Is a given variable undefined? + _.isUndefined = function(obj) { + return obj === void 0; + }; + + // Shortcut function for checking if an object has a given property directly + // on itself (in other words, not on a prototype). + _.has = function(obj, key) { + return obj != null && hasOwnProperty.call(obj, key); + }; + + // Utility Functions + // ----------------- + + // Run Underscore.js in *noConflict* mode, returning the `_` variable to its + // previous owner. Returns a reference to the Underscore object. + _.noConflict = function() { + root._ = previousUnderscore; + return this; + }; + + // Keep the identity function around for default iteratees. + _.identity = function(value) { + return value; + }; + + _.constant = function(value) { + return function() { + return value; + }; + }; + + _.noop = function(){}; + + _.property = function(key) { + return function(obj) { + return obj[key]; + }; + }; + + // Returns a predicate for checking whether an object has a given set of `key:value` pairs. + _.matches = function(attrs) { + var pairs = _.pairs(attrs), length = pairs.length; + return function(obj) { + if (obj == null) return !length; + obj = new Object(obj); + for (var i = 0; i < length; i++) { + var pair = pairs[i], key = pair[0]; + if (pair[1] !== obj[key] || !(key in obj)) return false; + } + return true; + }; + }; + + // Run a function **n** times. + _.times = function(n, iteratee, context) { + var accum = Array(Math.max(0, n)); + iteratee = createCallback(iteratee, context, 1); + for (var i = 0; i < n; i++) accum[i] = iteratee(i); + return accum; + }; + + // Return a random integer between min and max (inclusive). + _.random = function(min, max) { + if (max == null) { + max = min; + min = 0; + } + return min + Math.floor(Math.random() * (max - min + 1)); + }; + + // A (possibly faster) way to get the current timestamp as an integer. + _.now = Date.now || function() { + return new Date().getTime(); + }; + + // List of HTML entities for escaping. + var escapeMap = { + '&': '&', + '<': '<', + '>': '>', + '"': '"', + "'": ''', + '`': '`' + }; + var unescapeMap = _.invert(escapeMap); + + // Functions for escaping and unescaping strings to/from HTML interpolation. + var createEscaper = function(map) { + var escaper = function(match) { + return map[match]; + }; + // Regexes for identifying a key that needs to be escaped + var source = '(?:' + _.keys(map).join('|') + ')'; + var testRegexp = RegExp(source); + var replaceRegexp = RegExp(source, 'g'); + return function(string) { + string = string == null ? '' : '' + string; + return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string; + }; + }; + _.escape = createEscaper(escapeMap); + _.unescape = createEscaper(unescapeMap); + + // If the value of the named `property` is a function then invoke it with the + // `object` as context; otherwise, return it. + _.result = function(object, property) { + if (object == null) return void 0; + var value = object[property]; + return _.isFunction(value) ? object[property]() : value; + }; + + // Generate a unique integer id (unique within the entire client session). + // Useful for temporary DOM ids. + var idCounter = 0; + _.uniqueId = function(prefix) { + var id = ++idCounter + ''; + return prefix ? prefix + id : id; + }; + + // By default, Underscore uses ERB-style template delimiters, change the + // following template settings to use alternative delimiters. + _.templateSettings = { + evaluate : /<%([\s\S]+?)%>/g, + interpolate : /<%=([\s\S]+?)%>/g, + escape : /<%-([\s\S]+?)%>/g + }; + + // When customizing `templateSettings`, if you don't want to define an + // interpolation, evaluation or escaping regex, we need one that is + // guaranteed not to match. + var noMatch = /(.)^/; + + // Certain characters need to be escaped so that they can be put into a + // string literal. + var escapes = { + "'": "'", + '\\': '\\', + '\r': 'r', + '\n': 'n', + '\u2028': 'u2028', + '\u2029': 'u2029' + }; + + var escaper = /\\|'|\r|\n|\u2028|\u2029/g; + + var escapeChar = function(match) { + return '\\' + escapes[match]; + }; + + // JavaScript micro-templating, similar to John Resig's implementation. + // Underscore templating handles arbitrary delimiters, preserves whitespace, + // and correctly escapes quotes within interpolated code. + // NB: `oldSettings` only exists for backwards compatibility. + _.template = function(text, settings, oldSettings) { + if (!settings && oldSettings) settings = oldSettings; + settings = _.defaults({}, settings, _.templateSettings); + + // Combine delimiters into one regular expression via alternation. + var matcher = RegExp([ + (settings.escape || noMatch).source, + (settings.interpolate || noMatch).source, + (settings.evaluate || noMatch).source + ].join('|') + '|$', 'g'); + + // Compile the template source, escaping string literals appropriately. + var index = 0; + var source = "__p+='"; + text.replace(matcher, function(match, escape, interpolate, evaluate, offset) { + source += text.slice(index, offset).replace(escaper, escapeChar); + index = offset + match.length; + + if (escape) { + source += "'+\n((__t=(" + escape + "))==null?'':_.escape(__t))+\n'"; + } else if (interpolate) { + source += "'+\n((__t=(" + interpolate + "))==null?'':__t)+\n'"; + } else if (evaluate) { + source += "';\n" + evaluate + "\n__p+='"; + } + + // Adobe VMs need the match returned to produce the correct offest. + return match; + }); + source += "';\n"; + + // If a variable is not specified, place data values in local scope. + if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n'; + + source = "var __t,__p='',__j=Array.prototype.join," + + "print=function(){__p+=__j.call(arguments,'');};\n" + + source + 'return __p;\n'; + + try { + var render = new Function(settings.variable || 'obj', '_', source); + } catch (e) { + e.source = source; + throw e; + } + + var template = function(data) { + return render.call(this, data, _); + }; + + // Provide the compiled source as a convenience for precompilation. + var argument = settings.variable || 'obj'; + template.source = 'function(' + argument + '){\n' + source + '}'; + + return template; + }; + + // Add a "chain" function. Start chaining a wrapped Underscore object. + _.chain = function(obj) { + var instance = _(obj); + instance._chain = true; + return instance; + }; + + // OOP + // --------------- + // If Underscore is called as a function, it returns a wrapped object that + // can be used OO-style. This wrapper holds altered versions of all the + // underscore functions. Wrapped objects may be chained. + + // Helper function to continue chaining intermediate results. + var result = function(obj) { + return this._chain ? _(obj).chain() : obj; + }; + + // Add your own custom functions to the Underscore object. + _.mixin = function(obj) { + _.each(_.functions(obj), function(name) { + var func = _[name] = obj[name]; + _.prototype[name] = function() { + var args = [this._wrapped]; + push.apply(args, arguments); + return result.call(this, func.apply(_, args)); + }; + }); + }; + + // Add all of the Underscore functions to the wrapper object. + _.mixin(_); + + // Add all mutator Array functions to the wrapper. + _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) { + var method = ArrayProto[name]; + _.prototype[name] = function() { + var obj = this._wrapped; + method.apply(obj, arguments); + if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0]; + return result.call(this, obj); + }; + }); + + // Add all accessor Array functions to the wrapper. + _.each(['concat', 'join', 'slice'], function(name) { + var method = ArrayProto[name]; + _.prototype[name] = function() { + return result.call(this, method.apply(this._wrapped, arguments)); + }; + }); + + // Extracts the result from a wrapped and chained object. + _.prototype.value = function() { + return this._wrapped; + }; + + // AMD registration happens at the end for compatibility with AMD loaders + // that may not enforce next-turn semantics on modules. Even though general + // practice for AMD registration is to be anonymous, underscore registers + // as a named module because, like jQuery, it is a base library that is + // popular enough to be bundled in a third party lib, but not be part of + // an AMD load request. Those cases could generate an error when an + // anonymous define() is called outside of a loader request. + if (typeof define === 'function' && define.amd) { + define('underscore', [], function() { + return _; + }); + } +}.call(this)); + +},{}]},{},[2]) +//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/codio/workspace/node_modules/gulp-browserify/node_modules/browserify/node_modules/browser-pack/_prelude.js","/home/codio/workspace/lib/connector.coffee","/home/codio/workspace/lib/test-connector/test-connector.coffee","/home/codio/workspace/node_modules/underscore/underscore.js"],"names":[],"mappings":"AAAA;ACCA,IAAA,SAAA;;AAAA;AAEe,EAAA,mBAAA,GAAA;AAEX,IAAA,IAAC,CAAA,SAAD,GAAa,KAAb,CAAA;AAAA,IAEA,IAAC,CAAA,mBAAD,GAAuB,EAFvB,CAAA;AAAA,IAIA,IAAC,CAAA,WAAD,GAAe,EAJf,CAAA;AAAA,IAMA,IAAC,CAAA,oBAAD,GAAwB,EANxB,CAAA;AAAA,IAQA,IAAC,CAAA,gBAAD,GAAoB,EARpB,CAAA;AAAA,IAUA,IAAC,CAAA,kBAAD,GAAsB,EAVtB,CAFW;EAAA,CAAb;;AAAA,sBAkBA,UAAA,GAAY,SAAC,IAAD,GAAA;AACV,IAAA,IAAG,IAAC,CAAA,SAAJ;aACE,IAAK,CAAA,CAAA,CAAE,CAAC,KAAR,CAAc,IAAd,EAAoB,IAAK,SAAzB,EADF;KAAA,MAAA;aAGE,IAAC,CAAA,mBAAmB,CAAC,IAArB,CAA0B,IAA1B,EAHF;KADU;EAAA,CAlBZ,CAAA;;AAAA,sBA4BA,aAAA,GAAe,SAAC,CAAD,GAAA;WACb,IAAC,CAAA,gBAAgB,CAAC,IAAlB,CAAuB,CAAvB,EADa;EAAA,CA5Bf,CAAA;;AAAA,sBAoCA,SAAA,GAAW,SAAC,KAAD,EAAQ,OAAR,GAAA;WACT,IAAC,CAAA,UAAD,CAAY,CAAC,KAAD,EAAQ,KAAR,EAAe,OAAf,CAAZ,EADS;EAAA,CApCX,CAAA;;AAAA,sBA4CA,OAAA,GAAS,SAAC,IAAD,EAAO,OAAP,GAAA;WACP,IAAC,CAAA,UAAD,CAAY,CAAC,KAAD,EAAQ,IAAR,EAAc,OAAd,CAAZ,EADO;EAAA,CA5CT,CAAA;;AAAA,sBAmDA,SAAA,GAAW,SAAC,OAAD,GAAA;WACT,IAAC,CAAA,UAAD,CAAY;MAAC,CAAA,SAAA,KAAA,GAAA;eAAA,SAAA,GAAA;AACX,cAAA,4BAAA;AAAA;AAAA;eAAA,cAAA;gCAAA;AACE,0BAAA,KAAC,CAAA,KAAD,CAAO,MAAP,EAAe,OAAf,EAAA,CADF;AAAA;0BADW;QAAA,EAAA;MAAA,CAAA,CAAA,CAAA,IAAA,CAAD;KAAZ,EADS;EAAA,CAnDX,CAAA;;AAAA,sBAmEA,WAAA,GAAa,SAAA,GAAA;AACX,QAAA,qBAAA;AAAA;SAAS,gGAAT,GAAA;AACE,oBAAA,IAAC,CAAA,kBAAkB,CAAC,OAApB,CAA4B,SAAU,CAAA,CAAA,CAAtC,EAAA,CADF;AAAA;oBADW;EAAA,CAnEb,CAAA;;mBAAA;;IAFF,CAAA;;AAAA,MA2EM,CAAC,OAAP,GAAiB,SA3EjB,CAAA;;;;;ACAA,IAAA,2BAAA;EAAA;iSAAA;;AAAA,CAAA,GAAI,OAAA,CAAQ,YAAR,CAAJ,CAAA;;AAAA,SACA,GAAY,OAAA,CAAQ,cAAR,CADZ,CAAA;;AAAA;AAYE,kCAAA,CAAA;;AAAa,EAAA,uBAAE,EAAF,GAAA;AACX,IADY,IAAC,CAAA,KAAA,EACb,CAAA;AAAA,IAAA,6CAAA,CAAA,CAAA;AAAA,IAGA,IAAC,CAAA,eAAD,GAAmB,EAHnB,CAAA;AAAA,IAKA,IAAC,CAAA,cAAD,GAAkB,EALlB,CAAA;AAAA,IAMA,IAAC,CAAA,WAAD,GAAe,EANf,CAAA;AAAA,IAQA,IAAC,CAAA,aAAD,CAAe,CAAA,SAAA,KAAA,GAAA;aAAA,SAAC,IAAD,EAAO,OAAP,GAAA;eACb,KAAC,CAAA,eAAe,CAAC,IAAjB,CAAsB,OAAtB,EADa;MAAA,EAAA;IAAA,CAAA,CAAA,CAAA,IAAA,CAAf,CARA,CADW;EAAA,CAAb;;AAAA,0BAaA,IAAA,GAAM,SAAC,IAAD,GAAA;AACJ,QAAA,6CAAA;AAAA,IAAA,IAAC,CAAA,cAAD,CAAgB,IAAI,CAAC,EAArB,EAAyB,IAAzB,CAAA,CAAA;AACA;AAAA,SAAA,WAAA;oBAAA;AACE,MAAA,IAAC,CAAA,cAAD,CAAgB,GAAhB,EAAqB,CAArB,CAAA,CADF;AAAA,KADA;AAAA,IAGA,IAAC,CAAA,SAAD,GAAa,IAHb,CAAA;AAIA;AAAA;SAAA,4CAAA;uBAAA;AACE,oBAAA,IAAK,CAAA,CAAA,CAAE,CAAC,KAAR,CAAc,IAAd,EAAiB,IAAK,SAAtB,EAAA,CADF;AAAA;oBALI;EAAA,CAbN,CAAA;;AAAA,0BA0BA,cAAA,GAAgB,SAAC,EAAD,EAAK,cAAL,GAAA;AACd,QAAA,mCAAA;AAAA,IAAA,IAAO,4BAAP;AACE,MAAA,IAAA,GAAO,IAAP,CAAA;AAAA,MACA,SAAA,GAAY,IADZ,CAAA;AAEA,WAAS,iHAAT,GAAA;AACE,QAAA,KAAA,GAAQ,IAAC,CAAA,kBAAmB,CAAA,CAAA,CAAE,CAAC,IAAvB,CAA4B,IAA5B,EAA+B,SAA/B,CAAR,CAAA;AAAA,QACA,SAAA,GAAY,cAAc,CAAC,kBAAmB,CAAA,CAAA,CAAE,CAAC,IAArC,CAA0C,cAA1C,EAA0D,IAA1D,CADZ,CAAA;AAAA,QAEA,IAAA,GAAO,KAFP,CADF;AAAA,OAFA;AAAA,MAMA,IAAC,CAAA,WAAY,CAAA,EAAA,CAAb,GAAiB,cANjB,CAAA;aAOA,cAAc,CAAC,WAAY,CAAA,IAAC,CAAA,EAAD,CAA3B,GAAkC,KARpC;KADc;EAAA,CA1BhB,CAAA;;AAAA,0BAwCA,sBAAA,GAAwB,SAAA,GAAA;WACtB,IAAC,CAAA,gBADqB;EAAA,CAxCxB,CAAA;;AAAA,0BA+CA,KAAA,GAAO,SAAC,GAAD,EAAM,OAAN,GAAA;AACL,QAAA,SAAA;AAAA,IAAA,EAAA,GAAK,IAAC,CAAA,WAAY,CAAA,GAAA,CAAI,CAAC,cAAvB,CAAA;;MACA,YAAW;KADX;WAEA,EAAG,CAAA,IAAC,CAAA,EAAD,CAAI,CAAC,IAAR,CAAa,OAAb,EAHK;EAAA,CA/CP,CAAA;;AAAA,0BAuDA,QAAA,GAAU,SAAC,GAAD,GAAA;AACR,QAAA,2CAAA;AAAA,IAAA,qDAAuB,CAAE,gBAAtB,GAA+B,CAAlC;AACE,MAAA,OAAA,GAAU,IAAC,CAAA,cAAe,CAAA,GAAA,CAAI,CAAC,KAArB,CAAA,CAAV,CAAA;AACA;AAAA;WAAA,4CAAA;sBAAA;AACE,sBAAA,CAAA,CAAE,GAAF,EAAO,OAAP,EAAA,CADF;AAAA;sBAFF;KADQ;EAAA,CAvDV,CAAA;;AAAA,0BAgEA,cAAA,GAAgB,SAAA,GAAA;AACd,QAAA,gBAAA;AAAA,IAAA,QAAA;;AAAW;AAAA;WAAA,WAAA;sBAAA;AACT,sBAAA,IAAA,CADS;AAAA;;iBAAX,CAAA;WAEA,IAAC,CAAA,QAAD,CAAU,QAAS,CAAC,CAAC,CAAC,MAAF,CAAS,CAAT,EAAa,QAAQ,CAAC,MAAT,GAAgB,CAA7B,CAAD,CAAnB,EAHc;EAAA,CAhEhB,CAAA;;AAAA,0BAwEA,QAAA,GAAU,SAAA,GAAA;AACR,QAAA,yDAAA;AAAA;AAAA,SAAA,SAAA;yBAAA;AACE,WAAA,+CAAA;+BAAA;AACE;AAAA,aAAA,8CAAA;wBAAA;AACE,UAAA,CAAA,CAAE,CAAF,EAAK,OAAL,CAAA,CADF;AAAA,SADF;AAAA,OADF;AAAA,KAAA;WAIA,IAAC,CAAA,cAAD,GAAkB,GALV;EAAA,CAxEV,CAAA;;uBAAA;;GAN0B,UAN5B,CAAA;;AA4FA,IAAG,gDAAH;AACE,EAAA,MAAM,CAAC,aAAP,GAAuB,aAAvB,CADF;CA5FA;;AA+FA,IAAG,gDAAH;AACE,EAAA,MAAM,CAAC,OAAP,GAAiB,aAAjB,CADF;CA/FA;;;;;ACDA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require==\"function\"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);throw new Error(\"Cannot find module '\"+o+\"'\")}var f=n[o]={exports:{}};t[o][0].call(f.exports,function(e){var n=t[o][1][e];return s(n?n:e)},f,f.exports,e,t,n,r)}return n[o].exports}var i=typeof require==\"function\"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})","\nclass Connector\n  \n  constructor: ()->\n    # is set to true when this is synced with all other connections\n    @is_synced = false\n    # compute all of these functions when all connections are synced.\n    @compute_when_synced = []\n    # Peerjs Connections: key: conn-id, value: conn\n    @connections = {}\n    # Connections, that have been initialized, but have not been (fully) synced yet.\n    @unsynced_connections = {}\n    # List of functions that shall process incoming data\n    @receive_handlers = []\n    # A list of functions that are executed (left to right) when syncing with a peer. \n    @sync_process_order = []\n    \n  #\n  # Execute a function _when_ we are connected. If not connected, wait until connected.\n  # @param f {Function} Will be executed on the PeerJs-Connector context.\n  #\n  whenSynced: (args)->\n    if @is_synced\n      args[0].apply this, args[1..]\n    else\n      @compute_when_synced.push args \n  \n  #\n  # Execute an function _when_ a message is received.\n  # @param f {Function} Will be executed on the PeerJs-Connector context. f will be called with (sender_id, broadcast {true|false}, message).\n  #\n  whenReceiving: (f)->\n    @receive_handlers.push f\n  \n  #\n  # Send a message to a (sub)-set of all connected peers.\n  # @param peers {Array<connection_ids>} A set of ids.\n  # @param message {Object} The message to send.\n  #\n  multicast: (peers, message)->\n    @whenSynced [_send, peers, message]\n  \n  #\n  # Send a message to one of the connected peers.\n  # @param peers {connection_id} A connection id.\n  # @param message {Object} The message to send.\n  #\n  unicast: (peer, message)->\n    @whenSynced [_send, peer, message]\n  \n  # \n  # Broadcast a message to all connected peers.\n  # @param message {Object} The message to broadcast.\n  # \n  broadcast: (message)->\n    @whenSynced [()=>\n      for peerid,peer of @connections\n        @_send peerid, message]\n \n  #\n  # Define how you want to handle the sync process of two users.\n  # This is a synchronous handshake. Every user will perform exactly the same actions at the same time. E.g.\n  # @example\n  #   whenSyncing(function(){ // first call must not have parameters!\n  #       return this.id; // Send the id of this connector.\n  #   },function(peerid){ // you receive the peerid of the other connections.\n  #       // you can do something with the peerid\n  #       // return \"you are my friend\"; // you could send another massage.\n  #   }); // this is the end of the sync process.\n  #\n  whenSyncing: ()->\n    for i in [(arguments.length-1)..0]\n      @sync_process_order.unshift arguments[i]\n\n\n\nmodule.exports = Connector\n","\n_ = require \"underscore\"\nConnector = require '../connector'\n\n#\n# A trivial Connector that simulates network delay.\n#\nclass TestConnector extends Connector\n\n  #\n  # @param id {String} Some unique id\n  # @param user_connectors {Array<TestConnector>} List of TestConnectors instances\n  #\n  constructor: (@id)->\n    super()\n    # If you think of operations, this will mirror the \n    # execiton order of operations (when a message is send, or received it is put into this)\n    @execution_order = []\n    # The messages are buffered under the name of teh sending user.\n    @receive_buffer = {}\n    @connections = {}\n\n    @whenReceiving (user, message)=>\n      @execution_order.push message\n    \n  # join another user connector\n  join: (conn)->\n    @_addConnection conn.id, conn\n    for cid,c of conn.connections\n      @_addConnection cid, c\n    @is_synced = true\n    for comp in @compute_when_synced\n      comp[0].apply @, comp[1..]\n    \n  \n  #\n  # @private\n  # This is a helper function that is only related to the peerjs connector. \n  # Connect to another peer.\n  _addConnection: (id, user_connector)->\n    if not @connections[id]?\n      data = null\n      user_data = null\n      for i in [0...@sync_process_order.length]\n        data_ = @sync_process_order[i].call @, user_data\n        user_data = user_connector.sync_process_order[0].call user_connector, data\n        data = data_\n      @connections[id]=user_connector\n      user_connector.connections[@id] = @\n      \n  #\n  # Get the ops in the execution order.\n  #\n  getOpsInExecutionOrder: ()->\n    @execution_order\n    \n  #\n  # Send a message to another peer\n  # @param {Operation} o The operation that was executed.\n  #\n  _send: (uid, message)->\n    rb = @connections[uid].receive_buffer\n    rb[@id] ?= []\n    rb[@id].push message\n\n  #\n  # Flush one operation from the line of a specific user.\n  #\n  flushOne: (uid)->\n    if @receive_buffer[uid]?.length > 0\n      message = @receive_buffer[uid].shift()\n      for f in @receive_handlers\n        f uid, message\n        \n  #\n  # Flush one operation on a random line.\n  #\n  flushOneRandom: ()->\n    connlist = for cid,c of @receive_buffer\n      cid\n    @flushOne connlist[(_.random 0, (connlist.length-1))]\n\n  #\n  # Flush all operations on every line.\n  #\n  flushAll: ()->\n    for n,messages of @receive_buffer\n      for message in messages\n        for f in @receive_handlers\n          f n, message\n    @receive_buffer = {}\n\n\nif window?\n  window.TestConnector = TestConnector\n\nif module?\n  module.exports = TestConnector\n","//     Underscore.js 1.7.0\n//     http://underscorejs.org\n//     (c) 2009-2014 Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors\n//     Underscore may be freely distributed under the MIT license.\n\n(function() {\n\n  // Baseline setup\n  // --------------\n\n  // Establish the root object, `window` in the browser, or `exports` on the server.\n  var root = this;\n\n  // Save the previous value of the `_` variable.\n  var previousUnderscore = root._;\n\n  // Save bytes in the minified (but not gzipped) version:\n  var ArrayProto = Array.prototype, ObjProto = Object.prototype, FuncProto = Function.prototype;\n\n  // Create quick reference variables for speed access to core prototypes.\n  var\n    push             = ArrayProto.push,\n    slice            = ArrayProto.slice,\n    concat           = ArrayProto.concat,\n    toString         = ObjProto.toString,\n    hasOwnProperty   = ObjProto.hasOwnProperty;\n\n  // All **ECMAScript 5** native function implementations that we hope to use\n  // are declared here.\n  var\n    nativeIsArray      = Array.isArray,\n    nativeKeys         = Object.keys,\n    nativeBind         = FuncProto.bind;\n\n  // Create a safe reference to the Underscore object for use below.\n  var _ = function(obj) {\n    if (obj instanceof _) return obj;\n    if (!(this instanceof _)) return new _(obj);\n    this._wrapped = obj;\n  };\n\n  // Export the Underscore object for **Node.js**, with\n  // backwards-compatibility for the old `require()` API. If we're in\n  // the browser, add `_` as a global object.\n  if (typeof exports !== 'undefined') {\n    if (typeof module !== 'undefined' && module.exports) {\n      exports = module.exports = _;\n    }\n    exports._ = _;\n  } else {\n    root._ = _;\n  }\n\n  // Current version.\n  _.VERSION = '1.7.0';\n\n  // Internal function that returns an efficient (for current engines) version\n  // of the passed-in callback, to be repeatedly applied in other Underscore\n  // functions.\n  var createCallback = function(func, context, argCount) {\n    if (context === void 0) return func;\n    switch (argCount == null ? 3 : argCount) {\n      case 1: return function(value) {\n        return func.call(context, value);\n      };\n      case 2: return function(value, other) {\n        return func.call(context, value, other);\n      };\n      case 3: return function(value, index, collection) {\n        return func.call(context, value, index, collection);\n      };\n      case 4: return function(accumulator, value, index, collection) {\n        return func.call(context, accumulator, value, index, collection);\n      };\n    }\n    return function() {\n      return func.apply(context, arguments);\n    };\n  };\n\n  // A mostly-internal function to generate callbacks that can be applied\n  // to each element in a collection, returning the desired result — either\n  // identity, an arbitrary callback, a property matcher, or a property accessor.\n  _.iteratee = function(value, context, argCount) {\n    if (value == null) return _.identity;\n    if (_.isFunction(value)) return createCallback(value, context, argCount);\n    if (_.isObject(value)) return _.matches(value);\n    return _.property(value);\n  };\n\n  // Collection Functions\n  // --------------------\n\n  // The cornerstone, an `each` implementation, aka `forEach`.\n  // Handles raw objects in addition to array-likes. Treats all\n  // sparse array-likes as if they were dense.\n  _.each = _.forEach = function(obj, iteratee, context) {\n    if (obj == null) return obj;\n    iteratee = createCallback(iteratee, context);\n    var i, length = obj.length;\n    if (length === +length) {\n      for (i = 0; i < length; i++) {\n        iteratee(obj[i], i, obj);\n      }\n    } else {\n      var keys = _.keys(obj);\n      for (i = 0, length = keys.length; i < length; i++) {\n        iteratee(obj[keys[i]], keys[i], obj);\n      }\n    }\n    return obj;\n  };\n\n  // Return the results of applying the iteratee to each element.\n  _.map = _.collect = function(obj, iteratee, context) {\n    if (obj == null) return [];\n    iteratee = _.iteratee(iteratee, context);\n    var keys = obj.length !== +obj.length && _.keys(obj),\n        length = (keys || obj).length,\n        results = Array(length),\n        currentKey;\n    for (var index = 0; index < length; index++) {\n      currentKey = keys ? keys[index] : index;\n      results[index] = iteratee(obj[currentKey], currentKey, obj);\n    }\n    return results;\n  };\n\n  var reduceError = 'Reduce of empty array with no initial value';\n\n  // **Reduce** builds up a single result from a list of values, aka `inject`,\n  // or `foldl`.\n  _.reduce = _.foldl = _.inject = function(obj, iteratee, memo, context) {\n    if (obj == null) obj = [];\n    iteratee = createCallback(iteratee, context, 4);\n    var keys = obj.length !== +obj.length && _.keys(obj),\n        length = (keys || obj).length,\n        index = 0, currentKey;\n    if (arguments.length < 3) {\n      if (!length) throw new TypeError(reduceError);\n      memo = obj[keys ? keys[index++] : index++];\n    }\n    for (; index < length; index++) {\n      currentKey = keys ? keys[index] : index;\n      memo = iteratee(memo, obj[currentKey], currentKey, obj);\n    }\n    return memo;\n  };\n\n  // The right-associative version of reduce, also known as `foldr`.\n  _.reduceRight = _.foldr = function(obj, iteratee, memo, context) {\n    if (obj == null) obj = [];\n    iteratee = createCallback(iteratee, context, 4);\n    var keys = obj.length !== + obj.length && _.keys(obj),\n        index = (keys || obj).length,\n        currentKey;\n    if (arguments.length < 3) {\n      if (!index) throw new TypeError(reduceError);\n      memo = obj[keys ? keys[--index] : --index];\n    }\n    while (index--) {\n      currentKey = keys ? keys[index] : index;\n      memo = iteratee(memo, obj[currentKey], currentKey, obj);\n    }\n    return memo;\n  };\n\n  // Return the first value which passes a truth test. Aliased as `detect`.\n  _.find = _.detect = function(obj, predicate, context) {\n    var result;\n    predicate = _.iteratee(predicate, context);\n    _.some(obj, function(value, index, list) {\n      if (predicate(value, index, list)) {\n        result = value;\n        return true;\n      }\n    });\n    return result;\n  };\n\n  // Return all the elements that pass a truth test.\n  // Aliased as `select`.\n  _.filter = _.select = function(obj, predicate, context) {\n    var results = [];\n    if (obj == null) return results;\n    predicate = _.iteratee(predicate, context);\n    _.each(obj, function(value, index, list) {\n      if (predicate(value, index, list)) results.push(value);\n    });\n    return results;\n  };\n\n  // Return all the elements for which a truth test fails.\n  _.reject = function(obj, predicate, context) {\n    return _.filter(obj, _.negate(_.iteratee(predicate)), context);\n  };\n\n  // Determine whether all of the elements match a truth test.\n  // Aliased as `all`.\n  _.every = _.all = function(obj, predicate, context) {\n    if (obj == null) return true;\n    predicate = _.iteratee(predicate, context);\n    var keys = obj.length !== +obj.length && _.keys(obj),\n        length = (keys || obj).length,\n        index, currentKey;\n    for (index = 0; index < length; index++) {\n      currentKey = keys ? keys[index] : index;\n      if (!predicate(obj[currentKey], currentKey, obj)) return false;\n    }\n    return true;\n  };\n\n  // Determine if at least one element in the object matches a truth test.\n  // Aliased as `any`.\n  _.some = _.any = function(obj, predicate, context) {\n    if (obj == null) return false;\n    predicate = _.iteratee(predicate, context);\n    var keys = obj.length !== +obj.length && _.keys(obj),\n        length = (keys || obj).length,\n        index, currentKey;\n    for (index = 0; index < length; index++) {\n      currentKey = keys ? keys[index] : index;\n      if (predicate(obj[currentKey], currentKey, obj)) return true;\n    }\n    return false;\n  };\n\n  // Determine if the array or object contains a given value (using `===`).\n  // Aliased as `include`.\n  _.contains = _.include = function(obj, target) {\n    if (obj == null) return false;\n    if (obj.length !== +obj.length) obj = _.values(obj);\n    return _.indexOf(obj, target) >= 0;\n  };\n\n  // Invoke a method (with arguments) on every item in a collection.\n  _.invoke = function(obj, method) {\n    var args = slice.call(arguments, 2);\n    var isFunc = _.isFunction(method);\n    return _.map(obj, function(value) {\n      return (isFunc ? method : value[method]).apply(value, args);\n    });\n  };\n\n  // Convenience version of a common use case of `map`: fetching a property.\n  _.pluck = function(obj, key) {\n    return _.map(obj, _.property(key));\n  };\n\n  // Convenience version of a common use case of `filter`: selecting only objects\n  // containing specific `key:value` pairs.\n  _.where = function(obj, attrs) {\n    return _.filter(obj, _.matches(attrs));\n  };\n\n  // Convenience version of a common use case of `find`: getting the first object\n  // containing specific `key:value` pairs.\n  _.findWhere = function(obj, attrs) {\n    return _.find(obj, _.matches(attrs));\n  };\n\n  // Return the maximum element (or element-based computation).\n  _.max = function(obj, iteratee, context) {\n    var result = -Infinity, lastComputed = -Infinity,\n        value, computed;\n    if (iteratee == null && obj != null) {\n      obj = obj.length === +obj.length ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value > result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = _.iteratee(iteratee, context);\n      _.each(obj, function(value, index, list) {\n        computed = iteratee(value, index, list);\n        if (computed > lastComputed || computed === -Infinity && result === -Infinity) {\n          result = value;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Return the minimum element (or element-based computation).\n  _.min = function(obj, iteratee, context) {\n    var result = Infinity, lastComputed = Infinity,\n        value, computed;\n    if (iteratee == null && obj != null) {\n      obj = obj.length === +obj.length ? obj : _.values(obj);\n      for (var i = 0, length = obj.length; i < length; i++) {\n        value = obj[i];\n        if (value < result) {\n          result = value;\n        }\n      }\n    } else {\n      iteratee = _.iteratee(iteratee, context);\n      _.each(obj, function(value, index, list) {\n        computed = iteratee(value, index, list);\n        if (computed < lastComputed || computed === Infinity && result === Infinity) {\n          result = value;\n          lastComputed = computed;\n        }\n      });\n    }\n    return result;\n  };\n\n  // Shuffle a collection, using the modern version of the\n  // [Fisher-Yates shuffle](http://en.wikipedia.org/wiki/Fisher–Yates_shuffle).\n  _.shuffle = function(obj) {\n    var set = obj && obj.length === +obj.length ? obj : _.values(obj);\n    var length = set.length;\n    var shuffled = Array(length);\n    for (var index = 0, rand; index < length; index++) {\n      rand = _.random(0, index);\n      if (rand !== index) shuffled[index] = shuffled[rand];\n      shuffled[rand] = set[index];\n    }\n    return shuffled;\n  };\n\n  // Sample **n** random values from a collection.\n  // If **n** is not specified, returns a single random element.\n  // The internal `guard` argument allows it to work with `map`.\n  _.sample = function(obj, n, guard) {\n    if (n == null || guard) {\n      if (obj.length !== +obj.length) obj = _.values(obj);\n      return obj[_.random(obj.length - 1)];\n    }\n    return _.shuffle(obj).slice(0, Math.max(0, n));\n  };\n\n  // Sort the object's values by a criterion produced by an iteratee.\n  _.sortBy = function(obj, iteratee, context) {\n    iteratee = _.iteratee(iteratee, context);\n    return _.pluck(_.map(obj, function(value, index, list) {\n      return {\n        value: value,\n        index: index,\n        criteria: iteratee(value, index, list)\n      };\n    }).sort(function(left, right) {\n      var a = left.criteria;\n      var b = right.criteria;\n      if (a !== b) {\n        if (a > b || a === void 0) return 1;\n        if (a < b || b === void 0) return -1;\n      }\n      return left.index - right.index;\n    }), 'value');\n  };\n\n  // An internal function used for aggregate \"group by\" operations.\n  var group = function(behavior) {\n    return function(obj, iteratee, context) {\n      var result = {};\n      iteratee = _.iteratee(iteratee, context);\n      _.each(obj, function(value, index) {\n        var key = iteratee(value, index, obj);\n        behavior(result, value, key);\n      });\n      return result;\n    };\n  };\n\n  // Groups the object's values by a criterion. Pass either a string attribute\n  // to group by, or a function that returns the criterion.\n  _.groupBy = group(function(result, value, key) {\n    if (_.has(result, key)) result[key].push(value); else result[key] = [value];\n  });\n\n  // Indexes the object's values by a criterion, similar to `groupBy`, but for\n  // when you know that your index values will be unique.\n  _.indexBy = group(function(result, value, key) {\n    result[key] = value;\n  });\n\n  // Counts instances of an object that group by a certain criterion. Pass\n  // either a string attribute to count by, or a function that returns the\n  // criterion.\n  _.countBy = group(function(result, value, key) {\n    if (_.has(result, key)) result[key]++; else result[key] = 1;\n  });\n\n  // Use a comparator function to figure out the smallest index at which\n  // an object should be inserted so as to maintain order. Uses binary search.\n  _.sortedIndex = function(array, obj, iteratee, context) {\n    iteratee = _.iteratee(iteratee, context, 1);\n    var value = iteratee(obj);\n    var low = 0, high = array.length;\n    while (low < high) {\n      var mid = low + high >>> 1;\n      if (iteratee(array[mid]) < value) low = mid + 1; else high = mid;\n    }\n    return low;\n  };\n\n  // Safely create a real, live array from anything iterable.\n  _.toArray = function(obj) {\n    if (!obj) return [];\n    if (_.isArray(obj)) return slice.call(obj);\n    if (obj.length === +obj.length) return _.map(obj, _.identity);\n    return _.values(obj);\n  };\n\n  // Return the number of elements in an object.\n  _.size = function(obj) {\n    if (obj == null) return 0;\n    return obj.length === +obj.length ? obj.length : _.keys(obj).length;\n  };\n\n  // Split a collection into two arrays: one whose elements all satisfy the given\n  // predicate, and one whose elements all do not satisfy the predicate.\n  _.partition = function(obj, predicate, context) {\n    predicate = _.iteratee(predicate, context);\n    var pass = [], fail = [];\n    _.each(obj, function(value, key, obj) {\n      (predicate(value, key, obj) ? pass : fail).push(value);\n    });\n    return [pass, fail];\n  };\n\n  // Array Functions\n  // ---------------\n\n  // Get the first element of an array. Passing **n** will return the first N\n  // values in the array. Aliased as `head` and `take`. The **guard** check\n  // allows it to work with `_.map`.\n  _.first = _.head = _.take = function(array, n, guard) {\n    if (array == null) return void 0;\n    if (n == null || guard) return array[0];\n    if (n < 0) return [];\n    return slice.call(array, 0, n);\n  };\n\n  // Returns everything but the last entry of the array. Especially useful on\n  // the arguments object. Passing **n** will return all the values in\n  // the array, excluding the last N. The **guard** check allows it to work with\n  // `_.map`.\n  _.initial = function(array, n, guard) {\n    return slice.call(array, 0, Math.max(0, array.length - (n == null || guard ? 1 : n)));\n  };\n\n  // Get the last element of an array. Passing **n** will return the last N\n  // values in the array. The **guard** check allows it to work with `_.map`.\n  _.last = function(array, n, guard) {\n    if (array == null) return void 0;\n    if (n == null || guard) return array[array.length - 1];\n    return slice.call(array, Math.max(array.length - n, 0));\n  };\n\n  // Returns everything but the first entry of the array. Aliased as `tail` and `drop`.\n  // Especially useful on the arguments object. Passing an **n** will return\n  // the rest N values in the array. The **guard**\n  // check allows it to work with `_.map`.\n  _.rest = _.tail = _.drop = function(array, n, guard) {\n    return slice.call(array, n == null || guard ? 1 : n);\n  };\n\n  // Trim out all falsy values from an array.\n  _.compact = function(array) {\n    return _.filter(array, _.identity);\n  };\n\n  // Internal implementation of a recursive `flatten` function.\n  var flatten = function(input, shallow, strict, output) {\n    if (shallow && _.every(input, _.isArray)) {\n      return concat.apply(output, input);\n    }\n    for (var i = 0, length = input.length; i < length; i++) {\n      var value = input[i];\n      if (!_.isArray(value) && !_.isArguments(value)) {\n        if (!strict) output.push(value);\n      } else if (shallow) {\n        push.apply(output, value);\n      } else {\n        flatten(value, shallow, strict, output);\n      }\n    }\n    return output;\n  };\n\n  // Flatten out an array, either recursively (by default), or just one level.\n  _.flatten = function(array, shallow) {\n    return flatten(array, shallow, false, []);\n  };\n\n  // Return a version of the array that does not contain the specified value(s).\n  _.without = function(array) {\n    return _.difference(array, slice.call(arguments, 1));\n  };\n\n  // Produce a duplicate-free version of the array. If the array has already\n  // been sorted, you have the option of using a faster algorithm.\n  // Aliased as `unique`.\n  _.uniq = _.unique = function(array, isSorted, iteratee, context) {\n    if (array == null) return [];\n    if (!_.isBoolean(isSorted)) {\n      context = iteratee;\n      iteratee = isSorted;\n      isSorted = false;\n    }\n    if (iteratee != null) iteratee = _.iteratee(iteratee, context);\n    var result = [];\n    var seen = [];\n    for (var i = 0, length = array.length; i < length; i++) {\n      var value = array[i];\n      if (isSorted) {\n        if (!i || seen !== value) result.push(value);\n        seen = value;\n      } else if (iteratee) {\n        var computed = iteratee(value, i, array);\n        if (_.indexOf(seen, computed) < 0) {\n          seen.push(computed);\n          result.push(value);\n        }\n      } else if (_.indexOf(result, value) < 0) {\n        result.push(value);\n      }\n    }\n    return result;\n  };\n\n  // Produce an array that contains the union: each distinct element from all of\n  // the passed-in arrays.\n  _.union = function() {\n    return _.uniq(flatten(arguments, true, true, []));\n  };\n\n  // Produce an array that contains every item shared between all the\n  // passed-in arrays.\n  _.intersection = function(array) {\n    if (array == null) return [];\n    var result = [];\n    var argsLength = arguments.length;\n    for (var i = 0, length = array.length; i < length; i++) {\n      var item = array[i];\n      if (_.contains(result, item)) continue;\n      for (var j = 1; j < argsLength; j++) {\n        if (!_.contains(arguments[j], item)) break;\n      }\n      if (j === argsLength) result.push(item);\n    }\n    return result;\n  };\n\n  // Take the difference between one array and a number of other arrays.\n  // Only the elements present in just the first array will remain.\n  _.difference = function(array) {\n    var rest = flatten(slice.call(arguments, 1), true, true, []);\n    return _.filter(array, function(value){\n      return !_.contains(rest, value);\n    });\n  };\n\n  // Zip together multiple lists into a single array -- elements that share\n  // an index go together.\n  _.zip = function(array) {\n    if (array == null) return [];\n    var length = _.max(arguments, 'length').length;\n    var results = Array(length);\n    for (var i = 0; i < length; i++) {\n      results[i] = _.pluck(arguments, i);\n    }\n    return results;\n  };\n\n  // Converts lists into objects. Pass either a single array of `[key, value]`\n  // pairs, or two parallel arrays of the same length -- one of keys, and one of\n  // the corresponding values.\n  _.object = function(list, values) {\n    if (list == null) return {};\n    var result = {};\n    for (var i = 0, length = list.length; i < length; i++) {\n      if (values) {\n        result[list[i]] = values[i];\n      } else {\n        result[list[i][0]] = list[i][1];\n      }\n    }\n    return result;\n  };\n\n  // Return the position of the first occurrence of an item in an array,\n  // or -1 if the item is not included in the array.\n  // If the array is large and already in sort order, pass `true`\n  // for **isSorted** to use binary search.\n  _.indexOf = function(array, item, isSorted) {\n    if (array == null) return -1;\n    var i = 0, length = array.length;\n    if (isSorted) {\n      if (typeof isSorted == 'number') {\n        i = isSorted < 0 ? Math.max(0, length + isSorted) : isSorted;\n      } else {\n        i = _.sortedIndex(array, item);\n        return array[i] === item ? i : -1;\n      }\n    }\n    for (; i < length; i++) if (array[i] === item) return i;\n    return -1;\n  };\n\n  _.lastIndexOf = function(array, item, from) {\n    if (array == null) return -1;\n    var idx = array.length;\n    if (typeof from == 'number') {\n      idx = from < 0 ? idx + from + 1 : Math.min(idx, from + 1);\n    }\n    while (--idx >= 0) if (array[idx] === item) return idx;\n    return -1;\n  };\n\n  // Generate an integer Array containing an arithmetic progression. A port of\n  // the native Python `range()` function. See\n  // [the Python documentation](http://docs.python.org/library/functions.html#range).\n  _.range = function(start, stop, step) {\n    if (arguments.length <= 1) {\n      stop = start || 0;\n      start = 0;\n    }\n    step = step || 1;\n\n    var length = Math.max(Math.ceil((stop - start) / step), 0);\n    var range = Array(length);\n\n    for (var idx = 0; idx < length; idx++, start += step) {\n      range[idx] = start;\n    }\n\n    return range;\n  };\n\n  // Function (ahem) Functions\n  // ------------------\n\n  // Reusable constructor function for prototype setting.\n  var Ctor = function(){};\n\n  // Create a function bound to a given object (assigning `this`, and arguments,\n  // optionally). Delegates to **ECMAScript 5**'s native `Function.bind` if\n  // available.\n  _.bind = function(func, context) {\n    var args, bound;\n    if (nativeBind && func.bind === nativeBind) return nativeBind.apply(func, slice.call(arguments, 1));\n    if (!_.isFunction(func)) throw new TypeError('Bind must be called on a function');\n    args = slice.call(arguments, 2);\n    bound = function() {\n      if (!(this instanceof bound)) return func.apply(context, args.concat(slice.call(arguments)));\n      Ctor.prototype = func.prototype;\n      var self = new Ctor;\n      Ctor.prototype = null;\n      var result = func.apply(self, args.concat(slice.call(arguments)));\n      if (_.isObject(result)) return result;\n      return self;\n    };\n    return bound;\n  };\n\n  // Partially apply a function by creating a version that has had some of its\n  // arguments pre-filled, without changing its dynamic `this` context. _ acts\n  // as a placeholder, allowing any combination of arguments to be pre-filled.\n  _.partial = function(func) {\n    var boundArgs = slice.call(arguments, 1);\n    return function() {\n      var position = 0;\n      var args = boundArgs.slice();\n      for (var i = 0, length = args.length; i < length; i++) {\n        if (args[i] === _) args[i] = arguments[position++];\n      }\n      while (position < arguments.length) args.push(arguments[position++]);\n      return func.apply(this, args);\n    };\n  };\n\n  // Bind a number of an object's methods to that object. Remaining arguments\n  // are the method names to be bound. Useful for ensuring that all callbacks\n  // defined on an object belong to it.\n  _.bindAll = function(obj) {\n    var i, length = arguments.length, key;\n    if (length <= 1) throw new Error('bindAll must be passed function names');\n    for (i = 1; i < length; i++) {\n      key = arguments[i];\n      obj[key] = _.bind(obj[key], obj);\n    }\n    return obj;\n  };\n\n  // Memoize an expensive function by storing its results.\n  _.memoize = function(func, hasher) {\n    var memoize = function(key) {\n      var cache = memoize.cache;\n      var address = hasher ? hasher.apply(this, arguments) : key;\n      if (!_.has(cache, address)) cache[address] = func.apply(this, arguments);\n      return cache[address];\n    };\n    memoize.cache = {};\n    return memoize;\n  };\n\n  // Delays a function for the given number of milliseconds, and then calls\n  // it with the arguments supplied.\n  _.delay = function(func, wait) {\n    var args = slice.call(arguments, 2);\n    return setTimeout(function(){\n      return func.apply(null, args);\n    }, wait);\n  };\n\n  // Defers a function, scheduling it to run after the current call stack has\n  // cleared.\n  _.defer = function(func) {\n    return _.delay.apply(_, [func, 1].concat(slice.call(arguments, 1)));\n  };\n\n  // Returns a function, that, when invoked, will only be triggered at most once\n  // during a given window of time. Normally, the throttled function will run\n  // as much as it can, without ever going more than once per `wait` duration;\n  // but if you'd like to disable the execution on the leading edge, pass\n  // `{leading: false}`. To disable execution on the trailing edge, ditto.\n  _.throttle = function(func, wait, options) {\n    var context, args, result;\n    var timeout = null;\n    var previous = 0;\n    if (!options) options = {};\n    var later = function() {\n      previous = options.leading === false ? 0 : _.now();\n      timeout = null;\n      result = func.apply(context, args);\n      if (!timeout) context = args = null;\n    };\n    return function() {\n      var now = _.now();\n      if (!previous && options.leading === false) previous = now;\n      var remaining = wait - (now - previous);\n      context = this;\n      args = arguments;\n      if (remaining <= 0 || remaining > wait) {\n        clearTimeout(timeout);\n        timeout = null;\n        previous = now;\n        result = func.apply(context, args);\n        if (!timeout) context = args = null;\n      } else if (!timeout && options.trailing !== false) {\n        timeout = setTimeout(later, remaining);\n      }\n      return result;\n    };\n  };\n\n  // Returns a function, that, as long as it continues to be invoked, will not\n  // be triggered. The function will be called after it stops being called for\n  // N milliseconds. If `immediate` is passed, trigger the function on the\n  // leading edge, instead of the trailing.\n  _.debounce = function(func, wait, immediate) {\n    var timeout, args, context, timestamp, result;\n\n    var later = function() {\n      var last = _.now() - timestamp;\n\n      if (last < wait && last > 0) {\n        timeout = setTimeout(later, wait - last);\n      } else {\n        timeout = null;\n        if (!immediate) {\n          result = func.apply(context, args);\n          if (!timeout) context = args = null;\n        }\n      }\n    };\n\n    return function() {\n      context = this;\n      args = arguments;\n      timestamp = _.now();\n      var callNow = immediate && !timeout;\n      if (!timeout) timeout = setTimeout(later, wait);\n      if (callNow) {\n        result = func.apply(context, args);\n        context = args = null;\n      }\n\n      return result;\n    };\n  };\n\n  // Returns the first function passed as an argument to the second,\n  // allowing you to adjust arguments, run code before and after, and\n  // conditionally execute the original function.\n  _.wrap = function(func, wrapper) {\n    return _.partial(wrapper, func);\n  };\n\n  // Returns a negated version of the passed-in predicate.\n  _.negate = function(predicate) {\n    return function() {\n      return !predicate.apply(this, arguments);\n    };\n  };\n\n  // Returns a function that is the composition of a list of functions, each\n  // consuming the return value of the function that follows.\n  _.compose = function() {\n    var args = arguments;\n    var start = args.length - 1;\n    return function() {\n      var i = start;\n      var result = args[start].apply(this, arguments);\n      while (i--) result = args[i].call(this, result);\n      return result;\n    };\n  };\n\n  // Returns a function that will only be executed after being called N times.\n  _.after = function(times, func) {\n    return function() {\n      if (--times < 1) {\n        return func.apply(this, arguments);\n      }\n    };\n  };\n\n  // Returns a function that will only be executed before being called N times.\n  _.before = function(times, func) {\n    var memo;\n    return function() {\n      if (--times > 0) {\n        memo = func.apply(this, arguments);\n      } else {\n        func = null;\n      }\n      return memo;\n    };\n  };\n\n  // Returns a function that will be executed at most one time, no matter how\n  // often you call it. Useful for lazy initialization.\n  _.once = _.partial(_.before, 2);\n\n  // Object Functions\n  // ----------------\n\n  // Retrieve the names of an object's properties.\n  // Delegates to **ECMAScript 5**'s native `Object.keys`\n  _.keys = function(obj) {\n    if (!_.isObject(obj)) return [];\n    if (nativeKeys) return nativeKeys(obj);\n    var keys = [];\n    for (var key in obj) if (_.has(obj, key)) keys.push(key);\n    return keys;\n  };\n\n  // Retrieve the values of an object's properties.\n  _.values = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var values = Array(length);\n    for (var i = 0; i < length; i++) {\n      values[i] = obj[keys[i]];\n    }\n    return values;\n  };\n\n  // Convert an object into a list of `[key, value]` pairs.\n  _.pairs = function(obj) {\n    var keys = _.keys(obj);\n    var length = keys.length;\n    var pairs = Array(length);\n    for (var i = 0; i < length; i++) {\n      pairs[i] = [keys[i], obj[keys[i]]];\n    }\n    return pairs;\n  };\n\n  // Invert the keys and values of an object. The values must be serializable.\n  _.invert = function(obj) {\n    var result = {};\n    var keys = _.keys(obj);\n    for (var i = 0, length = keys.length; i < length; i++) {\n      result[obj[keys[i]]] = keys[i];\n    }\n    return result;\n  };\n\n  // Return a sorted list of the function names available on the object.\n  // Aliased as `methods`\n  _.functions = _.methods = function(obj) {\n    var names = [];\n    for (var key in obj) {\n      if (_.isFunction(obj[key])) names.push(key);\n    }\n    return names.sort();\n  };\n\n  // Extend a given object with all the properties in passed-in object(s).\n  _.extend = function(obj) {\n    if (!_.isObject(obj)) return obj;\n    var source, prop;\n    for (var i = 1, length = arguments.length; i < length; i++) {\n      source = arguments[i];\n      for (prop in source) {\n        if (hasOwnProperty.call(source, prop)) {\n            obj[prop] = source[prop];\n        }\n      }\n    }\n    return obj;\n  };\n\n  // Return a copy of the object only containing the whitelisted properties.\n  _.pick = function(obj, iteratee, context) {\n    var result = {}, key;\n    if (obj == null) return result;\n    if (_.isFunction(iteratee)) {\n      iteratee = createCallback(iteratee, context);\n      for (key in obj) {\n        var value = obj[key];\n        if (iteratee(value, key, obj)) result[key] = value;\n      }\n    } else {\n      var keys = concat.apply([], slice.call(arguments, 1));\n      obj = new Object(obj);\n      for (var i = 0, length = keys.length; i < length; i++) {\n        key = keys[i];\n        if (key in obj) result[key] = obj[key];\n      }\n    }\n    return result;\n  };\n\n   // Return a copy of the object without the blacklisted properties.\n  _.omit = function(obj, iteratee, context) {\n    if (_.isFunction(iteratee)) {\n      iteratee = _.negate(iteratee);\n    } else {\n      var keys = _.map(concat.apply([], slice.call(arguments, 1)), String);\n      iteratee = function(value, key) {\n        return !_.contains(keys, key);\n      };\n    }\n    return _.pick(obj, iteratee, context);\n  };\n\n  // Fill in a given object with default properties.\n  _.defaults = function(obj) {\n    if (!_.isObject(obj)) return obj;\n    for (var i = 1, length = arguments.length; i < length; i++) {\n      var source = arguments[i];\n      for (var prop in source) {\n        if (obj[prop] === void 0) obj[prop] = source[prop];\n      }\n    }\n    return obj;\n  };\n\n  // Create a (shallow-cloned) duplicate of an object.\n  _.clone = function(obj) {\n    if (!_.isObject(obj)) return obj;\n    return _.isArray(obj) ? obj.slice() : _.extend({}, obj);\n  };\n\n  // Invokes interceptor with the obj, and then returns obj.\n  // The primary purpose of this method is to \"tap into\" a method chain, in\n  // order to perform operations on intermediate results within the chain.\n  _.tap = function(obj, interceptor) {\n    interceptor(obj);\n    return obj;\n  };\n\n  // Internal recursive comparison function for `isEqual`.\n  var eq = function(a, b, aStack, bStack) {\n    // Identical objects are equal. `0 === -0`, but they aren't identical.\n    // See the [Harmony `egal` proposal](http://wiki.ecmascript.org/doku.php?id=harmony:egal).\n    if (a === b) return a !== 0 || 1 / a === 1 / b;\n    // A strict comparison is necessary because `null == undefined`.\n    if (a == null || b == null) return a === b;\n    // Unwrap any wrapped objects.\n    if (a instanceof _) a = a._wrapped;\n    if (b instanceof _) b = b._wrapped;\n    // Compare `[[Class]]` names.\n    var className = toString.call(a);\n    if (className !== toString.call(b)) return false;\n    switch (className) {\n      // Strings, numbers, regular expressions, dates, and booleans are compared by value.\n      case '[object RegExp]':\n      // RegExps are coerced to strings for comparison (Note: '' + /a/i === '/a/i')\n      case '[object String]':\n        // Primitives and their corresponding object wrappers are equivalent; thus, `\"5\"` is\n        // equivalent to `new String(\"5\")`.\n        return '' + a === '' + b;\n      case '[object Number]':\n        // `NaN`s are equivalent, but non-reflexive.\n        // Object(NaN) is equivalent to NaN\n        if (+a !== +a) return +b !== +b;\n        // An `egal` comparison is performed for other numeric values.\n        return +a === 0 ? 1 / +a === 1 / b : +a === +b;\n      case '[object Date]':\n      case '[object Boolean]':\n        // Coerce dates and booleans to numeric primitive values. Dates are compared by their\n        // millisecond representations. Note that invalid dates with millisecond representations\n        // of `NaN` are not equivalent.\n        return +a === +b;\n    }\n    if (typeof a != 'object' || typeof b != 'object') return false;\n    // Assume equality for cyclic structures. The algorithm for detecting cyclic\n    // structures is adapted from ES 5.1 section 15.12.3, abstract operation `JO`.\n    var length = aStack.length;\n    while (length--) {\n      // Linear search. Performance is inversely proportional to the number of\n      // unique nested structures.\n      if (aStack[length] === a) return bStack[length] === b;\n    }\n    // Objects with different constructors are not equivalent, but `Object`s\n    // from different frames are.\n    var aCtor = a.constructor, bCtor = b.constructor;\n    if (\n      aCtor !== bCtor &&\n      // Handle Object.create(x) cases\n      'constructor' in a && 'constructor' in b &&\n      !(_.isFunction(aCtor) && aCtor instanceof aCtor &&\n        _.isFunction(bCtor) && bCtor instanceof bCtor)\n    ) {\n      return false;\n    }\n    // Add the first object to the stack of traversed objects.\n    aStack.push(a);\n    bStack.push(b);\n    var size, result;\n    // Recursively compare objects and arrays.\n    if (className === '[object Array]') {\n      // Compare array lengths to determine if a deep comparison is necessary.\n      size = a.length;\n      result = size === b.length;\n      if (result) {\n        // Deep compare the contents, ignoring non-numeric properties.\n        while (size--) {\n          if (!(result = eq(a[size], b[size], aStack, bStack))) break;\n        }\n      }\n    } else {\n      // Deep compare objects.\n      var keys = _.keys(a), key;\n      size = keys.length;\n      // Ensure that both objects contain the same number of properties before comparing deep equality.\n      result = _.keys(b).length === size;\n      if (result) {\n        while (size--) {\n          // Deep compare each member\n          key = keys[size];\n          if (!(result = _.has(b, key) && eq(a[key], b[key], aStack, bStack))) break;\n        }\n      }\n    }\n    // Remove the first object from the stack of traversed objects.\n    aStack.pop();\n    bStack.pop();\n    return result;\n  };\n\n  // Perform a deep comparison to check if two objects are equal.\n  _.isEqual = function(a, b) {\n    return eq(a, b, [], []);\n  };\n\n  // Is a given array, string, or object empty?\n  // An \"empty\" object has no enumerable own-properties.\n  _.isEmpty = function(obj) {\n    if (obj == null) return true;\n    if (_.isArray(obj) || _.isString(obj) || _.isArguments(obj)) return obj.length === 0;\n    for (var key in obj) if (_.has(obj, key)) return false;\n    return true;\n  };\n\n  // Is a given value a DOM element?\n  _.isElement = function(obj) {\n    return !!(obj && obj.nodeType === 1);\n  };\n\n  // Is a given value an array?\n  // Delegates to ECMA5's native Array.isArray\n  _.isArray = nativeIsArray || function(obj) {\n    return toString.call(obj) === '[object Array]';\n  };\n\n  // Is a given variable an object?\n  _.isObject = function(obj) {\n    var type = typeof obj;\n    return type === 'function' || type === 'object' && !!obj;\n  };\n\n  // Add some isType methods: isArguments, isFunction, isString, isNumber, isDate, isRegExp.\n  _.each(['Arguments', 'Function', 'String', 'Number', 'Date', 'RegExp'], function(name) {\n    _['is' + name] = function(obj) {\n      return toString.call(obj) === '[object ' + name + ']';\n    };\n  });\n\n  // Define a fallback version of the method in browsers (ahem, IE), where\n  // there isn't any inspectable \"Arguments\" type.\n  if (!_.isArguments(arguments)) {\n    _.isArguments = function(obj) {\n      return _.has(obj, 'callee');\n    };\n  }\n\n  // Optimize `isFunction` if appropriate. Work around an IE 11 bug.\n  if (typeof /./ !== 'function') {\n    _.isFunction = function(obj) {\n      return typeof obj == 'function' || false;\n    };\n  }\n\n  // Is a given object a finite number?\n  _.isFinite = function(obj) {\n    return isFinite(obj) && !isNaN(parseFloat(obj));\n  };\n\n  // Is the given value `NaN`? (NaN is the only number which does not equal itself).\n  _.isNaN = function(obj) {\n    return _.isNumber(obj) && obj !== +obj;\n  };\n\n  // Is a given value a boolean?\n  _.isBoolean = function(obj) {\n    return obj === true || obj === false || toString.call(obj) === '[object Boolean]';\n  };\n\n  // Is a given value equal to null?\n  _.isNull = function(obj) {\n    return obj === null;\n  };\n\n  // Is a given variable undefined?\n  _.isUndefined = function(obj) {\n    return obj === void 0;\n  };\n\n  // Shortcut function for checking if an object has a given property directly\n  // on itself (in other words, not on a prototype).\n  _.has = function(obj, key) {\n    return obj != null && hasOwnProperty.call(obj, key);\n  };\n\n  // Utility Functions\n  // -----------------\n\n  // Run Underscore.js in *noConflict* mode, returning the `_` variable to its\n  // previous owner. Returns a reference to the Underscore object.\n  _.noConflict = function() {\n    root._ = previousUnderscore;\n    return this;\n  };\n\n  // Keep the identity function around for default iteratees.\n  _.identity = function(value) {\n    return value;\n  };\n\n  _.constant = function(value) {\n    return function() {\n      return value;\n    };\n  };\n\n  _.noop = function(){};\n\n  _.property = function(key) {\n    return function(obj) {\n      return obj[key];\n    };\n  };\n\n  // Returns a predicate for checking whether an object has a given set of `key:value` pairs.\n  _.matches = function(attrs) {\n    var pairs = _.pairs(attrs), length = pairs.length;\n    return function(obj) {\n      if (obj == null) return !length;\n      obj = new Object(obj);\n      for (var i = 0; i < length; i++) {\n        var pair = pairs[i], key = pair[0];\n        if (pair[1] !== obj[key] || !(key in obj)) return false;\n      }\n      return true;\n    };\n  };\n\n  // Run a function **n** times.\n  _.times = function(n, iteratee, context) {\n    var accum = Array(Math.max(0, n));\n    iteratee = createCallback(iteratee, context, 1);\n    for (var i = 0; i < n; i++) accum[i] = iteratee(i);\n    return accum;\n  };\n\n  // Return a random integer between min and max (inclusive).\n  _.random = function(min, max) {\n    if (max == null) {\n      max = min;\n      min = 0;\n    }\n    return min + Math.floor(Math.random() * (max - min + 1));\n  };\n\n  // A (possibly faster) way to get the current timestamp as an integer.\n  _.now = Date.now || function() {\n    return new Date().getTime();\n  };\n\n   // List of HTML entities for escaping.\n  var escapeMap = {\n    '&': '&amp;',\n    '<': '&lt;',\n    '>': '&gt;',\n    '\"': '&quot;',\n    \"'\": '&#x27;',\n    '`': '&#x60;'\n  };\n  var unescapeMap = _.invert(escapeMap);\n\n  // Functions for escaping and unescaping strings to/from HTML interpolation.\n  var createEscaper = function(map) {\n    var escaper = function(match) {\n      return map[match];\n    };\n    // Regexes for identifying a key that needs to be escaped\n    var source = '(?:' + _.keys(map).join('|') + ')';\n    var testRegexp = RegExp(source);\n    var replaceRegexp = RegExp(source, 'g');\n    return function(string) {\n      string = string == null ? '' : '' + string;\n      return testRegexp.test(string) ? string.replace(replaceRegexp, escaper) : string;\n    };\n  };\n  _.escape = createEscaper(escapeMap);\n  _.unescape = createEscaper(unescapeMap);\n\n  // If the value of the named `property` is a function then invoke it with the\n  // `object` as context; otherwise, return it.\n  _.result = function(object, property) {\n    if (object == null) return void 0;\n    var value = object[property];\n    return _.isFunction(value) ? object[property]() : value;\n  };\n\n  // Generate a unique integer id (unique within the entire client session).\n  // Useful for temporary DOM ids.\n  var idCounter = 0;\n  _.uniqueId = function(prefix) {\n    var id = ++idCounter + '';\n    return prefix ? prefix + id : id;\n  };\n\n  // By default, Underscore uses ERB-style template delimiters, change the\n  // following template settings to use alternative delimiters.\n  _.templateSettings = {\n    evaluate    : /<%([\\s\\S]+?)%>/g,\n    interpolate : /<%=([\\s\\S]+?)%>/g,\n    escape      : /<%-([\\s\\S]+?)%>/g\n  };\n\n  // When customizing `templateSettings`, if you don't want to define an\n  // interpolation, evaluation or escaping regex, we need one that is\n  // guaranteed not to match.\n  var noMatch = /(.)^/;\n\n  // Certain characters need to be escaped so that they can be put into a\n  // string literal.\n  var escapes = {\n    \"'\":      \"'\",\n    '\\\\':     '\\\\',\n    '\\r':     'r',\n    '\\n':     'n',\n    '\\u2028': 'u2028',\n    '\\u2029': 'u2029'\n  };\n\n  var escaper = /\\\\|'|\\r|\\n|\\u2028|\\u2029/g;\n\n  var escapeChar = function(match) {\n    return '\\\\' + escapes[match];\n  };\n\n  // JavaScript micro-templating, similar to John Resig's implementation.\n  // Underscore templating handles arbitrary delimiters, preserves whitespace,\n  // and correctly escapes quotes within interpolated code.\n  // NB: `oldSettings` only exists for backwards compatibility.\n  _.template = function(text, settings, oldSettings) {\n    if (!settings && oldSettings) settings = oldSettings;\n    settings = _.defaults({}, settings, _.templateSettings);\n\n    // Combine delimiters into one regular expression via alternation.\n    var matcher = RegExp([\n      (settings.escape || noMatch).source,\n      (settings.interpolate || noMatch).source,\n      (settings.evaluate || noMatch).source\n    ].join('|') + '|$', 'g');\n\n    // Compile the template source, escaping string literals appropriately.\n    var index = 0;\n    var source = \"__p+='\";\n    text.replace(matcher, function(match, escape, interpolate, evaluate, offset) {\n      source += text.slice(index, offset).replace(escaper, escapeChar);\n      index = offset + match.length;\n\n      if (escape) {\n        source += \"'+\\n((__t=(\" + escape + \"))==null?'':_.escape(__t))+\\n'\";\n      } else if (interpolate) {\n        source += \"'+\\n((__t=(\" + interpolate + \"))==null?'':__t)+\\n'\";\n      } else if (evaluate) {\n        source += \"';\\n\" + evaluate + \"\\n__p+='\";\n      }\n\n      // Adobe VMs need the match returned to produce the correct offest.\n      return match;\n    });\n    source += \"';\\n\";\n\n    // If a variable is not specified, place data values in local scope.\n    if (!settings.variable) source = 'with(obj||{}){\\n' + source + '}\\n';\n\n    source = \"var __t,__p='',__j=Array.prototype.join,\" +\n      \"print=function(){__p+=__j.call(arguments,'');};\\n\" +\n      source + 'return __p;\\n';\n\n    try {\n      var render = new Function(settings.variable || 'obj', '_', source);\n    } catch (e) {\n      e.source = source;\n      throw e;\n    }\n\n    var template = function(data) {\n      return render.call(this, data, _);\n    };\n\n    // Provide the compiled source as a convenience for precompilation.\n    var argument = settings.variable || 'obj';\n    template.source = 'function(' + argument + '){\\n' + source + '}';\n\n    return template;\n  };\n\n  // Add a \"chain\" function. Start chaining a wrapped Underscore object.\n  _.chain = function(obj) {\n    var instance = _(obj);\n    instance._chain = true;\n    return instance;\n  };\n\n  // OOP\n  // ---------------\n  // If Underscore is called as a function, it returns a wrapped object that\n  // can be used OO-style. This wrapper holds altered versions of all the\n  // underscore functions. Wrapped objects may be chained.\n\n  // Helper function to continue chaining intermediate results.\n  var result = function(obj) {\n    return this._chain ? _(obj).chain() : obj;\n  };\n\n  // Add your own custom functions to the Underscore object.\n  _.mixin = function(obj) {\n    _.each(_.functions(obj), function(name) {\n      var func = _[name] = obj[name];\n      _.prototype[name] = function() {\n        var args = [this._wrapped];\n        push.apply(args, arguments);\n        return result.call(this, func.apply(_, args));\n      };\n    });\n  };\n\n  // Add all of the Underscore functions to the wrapper object.\n  _.mixin(_);\n\n  // Add all mutator Array functions to the wrapper.\n  _.each(['pop', 'push', 'reverse', 'shift', 'sort', 'splice', 'unshift'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      var obj = this._wrapped;\n      method.apply(obj, arguments);\n      if ((name === 'shift' || name === 'splice') && obj.length === 0) delete obj[0];\n      return result.call(this, obj);\n    };\n  });\n\n  // Add all accessor Array functions to the wrapper.\n  _.each(['concat', 'join', 'slice'], function(name) {\n    var method = ArrayProto[name];\n    _.prototype[name] = function() {\n      return result.call(this, method.apply(this._wrapped, arguments));\n    };\n  });\n\n  // Extracts the result from a wrapped and chained object.\n  _.prototype.value = function() {\n    return this._wrapped;\n  };\n\n  // AMD registration happens at the end for compatibility with AMD loaders\n  // that may not enforce next-turn semantics on modules. Even though general\n  // practice for AMD registration is to be anonymous, underscore registers\n  // as a named module because, like jQuery, it is a base library that is\n  // popular enough to be bundled in a third party lib, but not be part of\n  // an AMD load request. Those cases could generate an error when an\n  // anonymous define() is called outside of a loader request.\n  if (typeof define === 'function' && define.amd) {\n    define('underscore', [], function() {\n      return _;\n    });\n  }\n}.call(this));\n"]} diff --git a/bower_components/connector/test-connector/test-connector.min.js b/bower_components/connector/test-connector/test-connector.min.js new file mode 100644 index 00000000..c08e9c51 --- /dev/null +++ b/bower_components/connector/test-connector/test-connector.min.js @@ -0,0 +1 @@ +!function n(t,r,e){function u(o,a){if(!r[o]){if(!t[o]){var c="function"==typeof require&&require;if(!a&&c)return c(o,!0);if(i)return i(o,!0);throw new Error("Cannot find module '"+o+"'")}var l=r[o]={exports:{}};t[o][0].call(l.exports,function(n){var r=t[o][1][n];return u(r?r:n)},l,l.exports,n,t,r,e)}return r[o].exports}for(var i="function"==typeof require&&require,o=0;o=r?0>=t:t>=0;n=0>=r?++t:--t)e.push(this.sync_process_order.unshift(arguments[n]));return e},n}(),t.exports=r},{}],2:[function(n,t){var r,e,u,i={}.hasOwnProperty,o=function(n,t){function r(){this.constructor=n}for(var e in t)i.call(t,e)&&(n[e]=t[e]);return r.prototype=t.prototype,n.prototype=new r,n.__super__=t.prototype,n};u=n("underscore"),r=n("../connector"),e=function(n){function t(n){this.id=n,t.__super__.constructor.call(this),this.execution_order=[],this.receive_buffer={},this.connections={},this.whenReceiving(function(n){return function(t,r){return n.execution_order.push(r)}}(this))}return o(t,n),t.prototype.join=function(n){var t,r,e,u,i,o,a,c;this._addConnection(n.id,n),o=n.connections;for(r in o)t=o[r],this._addConnection(r,t);for(this.is_synced=!0,a=this.compute_when_synced,c=[],u=0,i=a.length;i>u;u++)e=a[u],c.push(e[0].apply(this,e.slice(1)));return c},t.prototype._addConnection=function(n,t){var r,e,u,i,o,a;if(null==this.connections[n]){for(r=null,i=null,u=o=0,a=this.sync_process_order.length;a>=0?a>o:o>a;u=a>=0?++o:--o)e=this.sync_process_order[u].call(this,i),i=t.sync_process_order[0].call(t,r),r=e;return this.connections[n]=t,t.connections[this.id]=this}},t.prototype.getOpsInExecutionOrder=function(){return this.execution_order},t.prototype._send=function(n,t){var r,e;return r=this.connections[n].receive_buffer,null==r[e=this.id]&&(r[e]=[]),r[this.id].push(t)},t.prototype.flushOne=function(n){var t,r,e,u,i,o,a;if((null!=(i=this.receive_buffer[n])?i.length:void 0)>0){for(r=this.receive_buffer[n].shift(),o=this.receive_handlers,a=[],e=0,u=o.length;u>e;e++)t=o[e],a.push(t(n,r));return a}},t.prototype.flushOneRandom=function(){var n,t,r;return r=function(){var r,e;r=this.receive_buffer,e=[];for(t in r)n=r[t],e.push(t);return e}.call(this),this.flushOne(r[u.random(0,r.length-1)])},t.prototype.flushAll=function(){var n,t,r,e,u,i,o,a,c,l;c=this.receive_buffer;for(e in c)for(r=c[e],u=0,o=r.length;o>u;u++)for(t=r[u],l=this.receive_handlers,i=0,a=l.length;a>i;i++)(n=l[i])(e,t);return this.receive_buffer={}},t}(r),"undefined"!=typeof window&&null!==window&&(window.TestConnector=e),"undefined"!=typeof t&&null!==t&&(t.exports=e)},{"../connector":1,underscore:3}],3:[function(n,t,r){(function(){var n=this,e=n._,u=Array.prototype,i=Object.prototype,o=Function.prototype,a=u.push,c=u.slice,l=u.concat,s=i.toString,f=i.hasOwnProperty,h=Array.isArray,p=Object.keys,v=o.bind,g=function(n){return n instanceof g?n:this instanceof g?void(this._wrapped=n):new g(n)};"undefined"!=typeof r?("undefined"!=typeof t&&t.exports&&(r=t.exports=g),r._=g):n._=g,g.VERSION="1.7.0";var y=function(n,t,r){if(void 0===t)return n;switch(null==r?3:r){case 1:return function(r){return n.call(t,r)};case 2:return function(r,e){return n.call(t,r,e)};case 3:return function(r,e,u){return n.call(t,r,e,u)};case 4:return function(r,e,u,i){return n.call(t,r,e,u,i)}}return function(){return n.apply(t,arguments)}};g.iteratee=function(n,t,r){return null==n?g.identity:g.isFunction(n)?y(n,t,r):g.isObject(n)?g.matches(n):g.property(n)},g.each=g.forEach=function(n,t,r){if(null==n)return n;t=y(t,r);var e,u=n.length;if(u===+u)for(e=0;u>e;e++)t(n[e],e,n);else{var i=g.keys(n);for(e=0,u=i.length;u>e;e++)t(n[i[e]],i[e],n)}return n},g.map=g.collect=function(n,t,r){if(null==n)return[];t=g.iteratee(t,r);for(var e,u=n.length!==+n.length&&g.keys(n),i=(u||n).length,o=Array(i),a=0;i>a;a++)e=u?u[a]:a,o[a]=t(n[e],e,n);return o};var d="Reduce of empty array with no initial value";g.reduce=g.foldl=g.inject=function(n,t,r,e){null==n&&(n=[]),t=y(t,e,4);var u,i=n.length!==+n.length&&g.keys(n),o=(i||n).length,a=0;if(arguments.length<3){if(!o)throw new TypeError(d);r=n[i?i[a++]:a++]}for(;o>a;a++)u=i?i[a]:a,r=t(r,n[u],u,n);return r},g.reduceRight=g.foldr=function(n,t,r,e){null==n&&(n=[]),t=y(t,e,4);var u,i=n.length!==+n.length&&g.keys(n),o=(i||n).length;if(arguments.length<3){if(!o)throw new TypeError(d);r=n[i?i[--o]:--o]}for(;o--;)u=i?i[o]:o,r=t(r,n[u],u,n);return r},g.find=g.detect=function(n,t,r){var e;return t=g.iteratee(t,r),g.some(n,function(n,r,u){return t(n,r,u)?(e=n,!0):void 0}),e},g.filter=g.select=function(n,t,r){var e=[];return null==n?e:(t=g.iteratee(t,r),g.each(n,function(n,r,u){t(n,r,u)&&e.push(n)}),e)},g.reject=function(n,t,r){return g.filter(n,g.negate(g.iteratee(t)),r)},g.every=g.all=function(n,t,r){if(null==n)return!0;t=g.iteratee(t,r);var e,u,i=n.length!==+n.length&&g.keys(n),o=(i||n).length;for(e=0;o>e;e++)if(u=i?i[e]:e,!t(n[u],u,n))return!1;return!0},g.some=g.any=function(n,t,r){if(null==n)return!1;t=g.iteratee(t,r);var e,u,i=n.length!==+n.length&&g.keys(n),o=(i||n).length;for(e=0;o>e;e++)if(u=i?i[e]:e,t(n[u],u,n))return!0;return!1},g.contains=g.include=function(n,t){return null==n?!1:(n.length!==+n.length&&(n=g.values(n)),g.indexOf(n,t)>=0)},g.invoke=function(n,t){var r=c.call(arguments,2),e=g.isFunction(t);return g.map(n,function(n){return(e?t:n[t]).apply(n,r)})},g.pluck=function(n,t){return g.map(n,g.property(t))},g.where=function(n,t){return g.filter(n,g.matches(t))},g.findWhere=function(n,t){return g.find(n,g.matches(t))},g.max=function(n,t,r){var e,u,i=-1/0,o=-1/0;if(null==t&&null!=n){n=n.length===+n.length?n:g.values(n);for(var a=0,c=n.length;c>a;a++)e=n[a],e>i&&(i=e)}else t=g.iteratee(t,r),g.each(n,function(n,r,e){u=t(n,r,e),(u>o||u===-1/0&&i===-1/0)&&(i=n,o=u)});return i},g.min=function(n,t,r){var e,u,i=1/0,o=1/0;if(null==t&&null!=n){n=n.length===+n.length?n:g.values(n);for(var a=0,c=n.length;c>a;a++)e=n[a],i>e&&(i=e)}else t=g.iteratee(t,r),g.each(n,function(n,r,e){u=t(n,r,e),(o>u||1/0===u&&1/0===i)&&(i=n,o=u)});return i},g.shuffle=function(n){for(var t,r=n&&n.length===+n.length?n:g.values(n),e=r.length,u=Array(e),i=0;e>i;i++)t=g.random(0,i),t!==i&&(u[i]=u[t]),u[t]=r[i];return u},g.sample=function(n,t,r){return null==t||r?(n.length!==+n.length&&(n=g.values(n)),n[g.random(n.length-1)]):g.shuffle(n).slice(0,Math.max(0,t))},g.sortBy=function(n,t,r){return t=g.iteratee(t,r),g.pluck(g.map(n,function(n,r,e){return{value:n,index:r,criteria:t(n,r,e)}}).sort(function(n,t){var r=n.criteria,e=t.criteria;if(r!==e){if(r>e||void 0===r)return 1;if(e>r||void 0===e)return-1}return n.index-t.index}),"value")};var m=function(n){return function(t,r,e){var u={};return r=g.iteratee(r,e),g.each(t,function(e,i){var o=r(e,i,t);n(u,e,o)}),u}};g.groupBy=m(function(n,t,r){g.has(n,r)?n[r].push(t):n[r]=[t]}),g.indexBy=m(function(n,t,r){n[r]=t}),g.countBy=m(function(n,t,r){g.has(n,r)?n[r]++:n[r]=1}),g.sortedIndex=function(n,t,r,e){r=g.iteratee(r,e,1);for(var u=r(t),i=0,o=n.length;o>i;){var a=i+o>>>1;r(n[a])t?[]:c.call(n,0,t)},g.initial=function(n,t,r){return c.call(n,0,Math.max(0,n.length-(null==t||r?1:t)))},g.last=function(n,t,r){return null==n?void 0:null==t||r?n[n.length-1]:c.call(n,Math.max(n.length-t,0))},g.rest=g.tail=g.drop=function(n,t,r){return c.call(n,null==t||r?1:t)},g.compact=function(n){return g.filter(n,g.identity)};var _=function(n,t,r,e){if(t&&g.every(n,g.isArray))return l.apply(e,n);for(var u=0,i=n.length;i>u;u++){var o=n[u];g.isArray(o)||g.isArguments(o)?t?a.apply(e,o):_(o,t,r,e):r||e.push(o)}return e};g.flatten=function(n,t){return _(n,t,!1,[])},g.without=function(n){return g.difference(n,c.call(arguments,1))},g.uniq=g.unique=function(n,t,r,e){if(null==n)return[];g.isBoolean(t)||(e=r,r=t,t=!1),null!=r&&(r=g.iteratee(r,e));for(var u=[],i=[],o=0,a=n.length;a>o;o++){var c=n[o];if(t)o&&i===c||u.push(c),i=c;else if(r){var l=r(c,o,n);g.indexOf(i,l)<0&&(i.push(l),u.push(c))}else g.indexOf(u,c)<0&&u.push(c)}return u},g.union=function(){return g.uniq(_(arguments,!0,!0,[]))},g.intersection=function(n){if(null==n)return[];for(var t=[],r=arguments.length,e=0,u=n.length;u>e;e++){var i=n[e];if(!g.contains(t,i)){for(var o=1;r>o&&g.contains(arguments[o],i);o++);o===r&&t.push(i)}}return t},g.difference=function(n){var t=_(c.call(arguments,1),!0,!0,[]);return g.filter(n,function(n){return!g.contains(t,n)})},g.zip=function(n){if(null==n)return[];for(var t=g.max(arguments,"length").length,r=Array(t),e=0;t>e;e++)r[e]=g.pluck(arguments,e);return r},g.object=function(n,t){if(null==n)return{};for(var r={},e=0,u=n.length;u>e;e++)t?r[n[e]]=t[e]:r[n[e][0]]=n[e][1];return r},g.indexOf=function(n,t,r){if(null==n)return-1;var e=0,u=n.length;if(r){if("number"!=typeof r)return e=g.sortedIndex(n,t),n[e]===t?e:-1;e=0>r?Math.max(0,u+r):r}for(;u>e;e++)if(n[e]===t)return e;return-1},g.lastIndexOf=function(n,t,r){if(null==n)return-1;var e=n.length;for("number"==typeof r&&(e=0>r?e+r+1:Math.min(e,r+1));--e>=0;)if(n[e]===t)return e;return-1},g.range=function(n,t,r){arguments.length<=1&&(t=n||0,n=0),r=r||1;for(var e=Math.max(Math.ceil((t-n)/r),0),u=Array(e),i=0;e>i;i++,n+=r)u[i]=n;return u};var w=function(){};g.bind=function(n,t){var r,e;if(v&&n.bind===v)return v.apply(n,c.call(arguments,1));if(!g.isFunction(n))throw new TypeError("Bind must be called on a function");return r=c.call(arguments,2),e=function(){if(!(this instanceof e))return n.apply(t,r.concat(c.call(arguments)));w.prototype=n.prototype;var u=new w;w.prototype=null;var i=n.apply(u,r.concat(c.call(arguments)));return g.isObject(i)?i:u}},g.partial=function(n){var t=c.call(arguments,1);return function(){for(var r=0,e=t.slice(),u=0,i=e.length;i>u;u++)e[u]===g&&(e[u]=arguments[r++]);for(;r=e)throw new Error("bindAll must be passed function names");for(t=1;e>t;t++)r=arguments[t],n[r]=g.bind(n[r],n);return n},g.memoize=function(n,t){var r=function(e){var u=r.cache,i=t?t.apply(this,arguments):e;return g.has(u,i)||(u[i]=n.apply(this,arguments)),u[i]};return r.cache={},r},g.delay=function(n,t){var r=c.call(arguments,2);return setTimeout(function(){return n.apply(null,r)},t)},g.defer=function(n){return g.delay.apply(g,[n,1].concat(c.call(arguments,1)))},g.throttle=function(n,t,r){var e,u,i,o=null,a=0;r||(r={});var c=function(){a=r.leading===!1?0:g.now(),o=null,i=n.apply(e,u),o||(e=u=null)};return function(){var l=g.now();a||r.leading!==!1||(a=l);var s=t-(l-a);return e=this,u=arguments,0>=s||s>t?(clearTimeout(o),o=null,a=l,i=n.apply(e,u),o||(e=u=null)):o||r.trailing===!1||(o=setTimeout(c,s)),i}},g.debounce=function(n,t,r){var e,u,i,o,a,c=function(){var l=g.now()-o;t>l&&l>0?e=setTimeout(c,t-l):(e=null,r||(a=n.apply(i,u),e||(i=u=null)))};return function(){i=this,u=arguments,o=g.now();var l=r&&!e;return e||(e=setTimeout(c,t)),l&&(a=n.apply(i,u),i=u=null),a}},g.wrap=function(n,t){return g.partial(t,n)},g.negate=function(n){return function(){return!n.apply(this,arguments)}},g.compose=function(){var n=arguments,t=n.length-1;return function(){for(var r=t,e=n[t].apply(this,arguments);r--;)e=n[r].call(this,e);return e}},g.after=function(n,t){return function(){return--n<1?t.apply(this,arguments):void 0}},g.before=function(n,t){var r;return function(){return--n>0?r=t.apply(this,arguments):t=null,r}},g.once=g.partial(g.before,2),g.keys=function(n){if(!g.isObject(n))return[];if(p)return p(n);var t=[];for(var r in n)g.has(n,r)&&t.push(r);return t},g.values=function(n){for(var t=g.keys(n),r=t.length,e=Array(r),u=0;r>u;u++)e[u]=n[t[u]];return e},g.pairs=function(n){for(var t=g.keys(n),r=t.length,e=Array(r),u=0;r>u;u++)e[u]=[t[u],n[t[u]]];return e},g.invert=function(n){for(var t={},r=g.keys(n),e=0,u=r.length;u>e;e++)t[n[r[e]]]=r[e];return t},g.functions=g.methods=function(n){var t=[];for(var r in n)g.isFunction(n[r])&&t.push(r);return t.sort()},g.extend=function(n){if(!g.isObject(n))return n;for(var t,r,e=1,u=arguments.length;u>e;e++){t=arguments[e];for(r in t)f.call(t,r)&&(n[r]=t[r])}return n},g.pick=function(n,t,r){var e,u={};if(null==n)return u;if(g.isFunction(t)){t=y(t,r);for(e in n){var i=n[e];t(i,e,n)&&(u[e]=i)}}else{var o=l.apply([],c.call(arguments,1));n=new Object(n);for(var a=0,s=o.length;s>a;a++)e=o[a],e in n&&(u[e]=n[e])}return u},g.omit=function(n,t,r){if(g.isFunction(t))t=g.negate(t);else{var e=g.map(l.apply([],c.call(arguments,1)),String);t=function(n,t){return!g.contains(e,t)}}return g.pick(n,t,r)},g.defaults=function(n){if(!g.isObject(n))return n;for(var t=1,r=arguments.length;r>t;t++){var e=arguments[t];for(var u in e)void 0===n[u]&&(n[u]=e[u])}return n},g.clone=function(n){return g.isObject(n)?g.isArray(n)?n.slice():g.extend({},n):n},g.tap=function(n,t){return t(n),n};var b=function(n,t,r,e){if(n===t)return 0!==n||1/n===1/t;if(null==n||null==t)return n===t;n instanceof g&&(n=n._wrapped),t instanceof g&&(t=t._wrapped);var u=s.call(n);if(u!==s.call(t))return!1;switch(u){case"[object RegExp]":case"[object String]":return""+n==""+t;case"[object Number]":return+n!==+n?+t!==+t:0===+n?1/+n===1/t:+n===+t;case"[object Date]":case"[object Boolean]":return+n===+t}if("object"!=typeof n||"object"!=typeof t)return!1;for(var i=r.length;i--;)if(r[i]===n)return e[i]===t;var o=n.constructor,a=t.constructor;if(o!==a&&"constructor"in n&&"constructor"in t&&!(g.isFunction(o)&&o instanceof o&&g.isFunction(a)&&a instanceof a))return!1;r.push(n),e.push(t);var c,l;if("[object Array]"===u){if(c=n.length,l=c===t.length)for(;c--&&(l=b(n[c],t[c],r,e)););}else{var f,h=g.keys(n);if(c=h.length,l=g.keys(t).length===c)for(;c--&&(f=h[c],l=g.has(t,f)&&b(n[f],t[f],r,e)););}return r.pop(),e.pop(),l};g.isEqual=function(n,t){return b(n,t,[],[])},g.isEmpty=function(n){if(null==n)return!0;if(g.isArray(n)||g.isString(n)||g.isArguments(n))return 0===n.length;for(var t in n)if(g.has(n,t))return!1;return!0},g.isElement=function(n){return!(!n||1!==n.nodeType)},g.isArray=h||function(n){return"[object Array]"===s.call(n)},g.isObject=function(n){var t=typeof n;return"function"===t||"object"===t&&!!n},g.each(["Arguments","Function","String","Number","Date","RegExp"],function(n){g["is"+n]=function(t){return s.call(t)==="[object "+n+"]"}}),g.isArguments(arguments)||(g.isArguments=function(n){return g.has(n,"callee")}),"function"!=typeof/./&&(g.isFunction=function(n){return"function"==typeof n||!1}),g.isFinite=function(n){return isFinite(n)&&!isNaN(parseFloat(n))},g.isNaN=function(n){return g.isNumber(n)&&n!==+n},g.isBoolean=function(n){return n===!0||n===!1||"[object Boolean]"===s.call(n)},g.isNull=function(n){return null===n},g.isUndefined=function(n){return void 0===n},g.has=function(n,t){return null!=n&&f.call(n,t)},g.noConflict=function(){return n._=e,this},g.identity=function(n){return n},g.constant=function(n){return function(){return n}},g.noop=function(){},g.property=function(n){return function(t){return t[n]}},g.matches=function(n){var t=g.pairs(n),r=t.length;return function(n){if(null==n)return!r;n=new Object(n);for(var e=0;r>e;e++){var u=t[e],i=u[0];if(u[1]!==n[i]||!(i in n))return!1}return!0}},g.times=function(n,t,r){var e=Array(Math.max(0,n));t=y(t,r,1);for(var u=0;n>u;u++)e[u]=t(u);return e},g.random=function(n,t){return null==t&&(t=n,n=0),n+Math.floor(Math.random()*(t-n+1))},g.now=Date.now||function(){return(new Date).getTime()};var x={"&":"&","<":"<",">":">",'"':""","'":"'","`":"`"},j=g.invert(x),A=function(n){var t=function(t){return n[t]},r="(?:"+g.keys(n).join("|")+")",e=RegExp(r),u=RegExp(r,"g");return function(n){return n=null==n?"":""+n,e.test(n)?n.replace(u,t):n}};g.escape=A(x),g.unescape=A(j),g.result=function(n,t){if(null==n)return void 0;var r=n[t];return g.isFunction(r)?n[t]():r};var O=0;g.uniqueId=function(n){var t=++O+"";return n?n+t:t},g.templateSettings={evaluate:/<%([\s\S]+?)%>/g,interpolate:/<%=([\s\S]+?)%>/g,escape:/<%-([\s\S]+?)%>/g};var k=/(.)^/,E={"'":"'","\\":"\\","\r":"r","\n":"n","\u2028":"u2028","\u2029":"u2029"},F=/\\|'|\r|\n|\u2028|\u2029/g,S=function(n){return"\\"+E[n]};g.template=function(n,t,r){!t&&r&&(t=r),t=g.defaults({},t,g.templateSettings);var e=RegExp([(t.escape||k).source,(t.interpolate||k).source,(t.evaluate||k).source].join("|")+"|$","g"),u=0,i="__p+='";n.replace(e,function(t,r,e,o,a){return i+=n.slice(u,a).replace(F,S),u=a+t.length,r?i+="'+\n((__t=("+r+"))==null?'':_.escape(__t))+\n'":e?i+="'+\n((__t=("+e+"))==null?'':__t)+\n'":o&&(i+="';\n"+o+"\n__p+='"),t}),i+="';\n",t.variable||(i="with(obj||{}){\n"+i+"}\n"),i="var __t,__p='',__j=Array.prototype.join,print=function(){__p+=__j.call(arguments,'');};\n"+i+"return __p;\n";try{var o=new Function(t.variable||"obj","_",i)}catch(a){throw a.source=i,a}var c=function(n){return o.call(this,n,g)},l=t.variable||"obj";return c.source="function("+l+"){\n"+i+"}",c},g.chain=function(n){var t=g(n);return t._chain=!0,t};var R=function(n){return this._chain?g(n).chain():n};g.mixin=function(n){g.each(g.functions(n),function(t){var r=g[t]=n[t];g.prototype[t]=function(){var n=[this._wrapped];return a.apply(n,arguments),R.call(this,r.apply(g,n))}})},g.mixin(g),g.each(["pop","push","reverse","shift","sort","splice","unshift"],function(n){var t=u[n];g.prototype[n]=function(){var r=this._wrapped;return t.apply(r,arguments),"shift"!==n&&"splice"!==n||0!==r.length||delete r[0],R.call(this,r)}}),g.each(["concat","join","slice"],function(n){var t=u[n];g.prototype[n]=function(){return R.call(this,t.apply(this._wrapped,arguments))}}),g.prototype.value=function(){return this._wrapped},"function"==typeof define&&define.amd&&define("underscore",[],function(){return g})}).call(this)},{}]},{},[2]); \ No newline at end of file diff --git a/bower_components/core-component-page/.bower.json b/bower_components/core-component-page/.bower.json new file mode 100644 index 00000000..5ae06f23 --- /dev/null +++ b/bower_components/core-component-page/.bower.json @@ -0,0 +1,19 @@ +{ + "name": "core-component-page", + "private": true, + "dependencies": { + "webcomponentsjs": "Polymer/webcomponentsjs#^0.5.0", + "polymer": "Polymer/polymer#^0.5.0" + }, + "version": "0.5.1", + "homepage": "https://github.com/Polymer/core-component-page", + "_release": "0.5.1", + "_resolution": { + "type": "version", + "tag": "0.5.1", + "commit": "ef1f86e659fd7498755e027d1561acc963d67807" + }, + "_source": "git://github.com/Polymer/core-component-page.git", + "_target": "^0.5.0", + "_originalSource": "Polymer/core-component-page" +} \ No newline at end of file diff --git a/bower_components/core-component-page/README.md b/bower_components/core-component-page/README.md new file mode 100644 index 00000000..7cb18ec7 --- /dev/null +++ b/bower_components/core-component-page/README.md @@ -0,0 +1,6 @@ +core-component-page +=================== + +See the [component page](http://polymer-project.org/docs/elements/core-elements.html#core-component-page) for more information. + +Note: this is the vulcanized version of [`core-component-page-dev`](https://github.com/Polymer/core-component-page-dev) (the source). diff --git a/bower_components/core-component-page/bowager-logo.png b/bower_components/core-component-page/bowager-logo.png new file mode 100644 index 00000000..76be9fb0 Binary files /dev/null and b/bower_components/core-component-page/bowager-logo.png differ diff --git a/bower_components/core-component-page/bower.json b/bower_components/core-component-page/bower.json new file mode 100644 index 00000000..356fc3db --- /dev/null +++ b/bower_components/core-component-page/bower.json @@ -0,0 +1,9 @@ +{ + "name": "core-component-page", + "private": true, + "dependencies": { + "webcomponentsjs": "Polymer/webcomponentsjs#^0.5.0", + "polymer": "Polymer/polymer#^0.5.0" + }, + "version": "0.5.1" +} \ No newline at end of file diff --git a/bower_components/core-component-page/core-component-page.html b/bower_components/core-component-page/core-component-page.html new file mode 100644 index 00000000..5c642c77 --- /dev/null +++ b/bower_components/core-component-page/core-component-page.html @@ -0,0 +1,37 @@ + + + + + + + + + + diff --git a/bower_components/core-component-page/demo.html b/bower_components/core-component-page/demo.html new file mode 100644 index 00000000..3c414d85 --- /dev/null +++ b/bower_components/core-component-page/demo.html @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + diff --git a/bower_components/core-component-page/index.html b/bower_components/core-component-page/index.html new file mode 100644 index 00000000..294215a7 --- /dev/null +++ b/bower_components/core-component-page/index.html @@ -0,0 +1,22 @@ + + + + + + + + + + + + + + + diff --git a/bower_components/polymer/.bower.json b/bower_components/polymer/.bower.json new file mode 100644 index 00000000..1361f340 --- /dev/null +++ b/bower_components/polymer/.bower.json @@ -0,0 +1,32 @@ +{ + "name": "polymer", + "description": "Polymer is a new type of library for the web, built on top of Web Components, and designed to leverage the evolving web platform on modern browsers.", + "homepage": "http://www.polymer-project.org/", + "keywords": [ + "util", + "client", + "browser", + "web components", + "web-components" + ], + "author": "Polymer Authors ", + "private": true, + "dependencies": { + "core-component-page": "Polymer/core-component-page#^0.5.0", + "webcomponentsjs": "Polymer/webcomponentsjs#^0.5.0" + }, + "devDependencies": { + "tools": "Polymer/tools#master", + "web-component-tester": "Polymer/web-component-tester#^1.4.2" + }, + "version": "0.5.1", + "_release": "0.5.1", + "_resolution": { + "type": "version", + "tag": "0.5.1", + "commit": "c654b2b4996a643e79234ac624d7bc38179dfc2c" + }, + "_source": "git://github.com/Polymer/polymer.git", + "_target": "~0.5.1", + "_originalSource": "Polymer/polymer" +} \ No newline at end of file diff --git a/bower_components/polymer/README.md b/bower_components/polymer/README.md new file mode 100644 index 00000000..68755353 --- /dev/null +++ b/bower_components/polymer/README.md @@ -0,0 +1,21 @@ +# Polymer + +[![Polymer build status](http://www.polymer-project.org/build/polymer-dev/status.png "Polymer build status")](http://build.chromium.org/p/client.polymer/waterfall) + +## Brief Overview + +For more detailed info goto [http://polymer-project.org/](http://polymer-project.org/). + +Polymer is a new type of library for the web, designed to leverage the existing browser infrastructure to provide the encapsulation and extendability currently only available in JS libraries. + +Polymer is based on a set of future technologies, including [Shadow DOM](https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/shadow/index.html), [Custom Elements](https://dvcs.w3.org/hg/webcomponents/raw-file/tip/spec/custom/index.html) and Model Driven Views. Currently these technologies are implemented as polyfills or shims, but as browsers adopt these features natively, the platform code that drives Polymer evacipates, leaving only the value-adds. + +## Tools & Testing + +For running tests or building minified files, consult the [tooling information](http://polymer-project.org/resources/tooling-strategy.html). + +## Releases + +[Release (tagged) versions](https://github.com/Polymer/polymer/releases) of Polymer include concatenated and minified sources for your convenience. + +[![Analytics](https://ga-beacon.appspot.com/UA-39334307-2/Polymer/polymer/README)](https://github.com/igrigorik/ga-beacon) diff --git a/bower_components/polymer/bower.json b/bower_components/polymer/bower.json new file mode 100644 index 00000000..2dfde95f --- /dev/null +++ b/bower_components/polymer/bower.json @@ -0,0 +1,23 @@ +{ + "name": "polymer", + "description": "Polymer is a new type of library for the web, built on top of Web Components, and designed to leverage the evolving web platform on modern browsers.", + "homepage": "http://www.polymer-project.org/", + "keywords": [ + "util", + "client", + "browser", + "web components", + "web-components" + ], + "author": "Polymer Authors ", + "private": true, + "dependencies": { + "core-component-page": "Polymer/core-component-page#^0.5.0", + "webcomponentsjs": "Polymer/webcomponentsjs#^0.5.0" + }, + "devDependencies": { + "tools": "Polymer/tools#master", + "web-component-tester": "Polymer/web-component-tester#^1.4.2" + }, + "version": "0.5.1" +} \ No newline at end of file diff --git a/bower_components/polymer/build.log b/bower_components/polymer/build.log new file mode 100644 index 00000000..dee50c20 --- /dev/null +++ b/bower_components/polymer/build.log @@ -0,0 +1,26 @@ +BUILD LOG +--------- +Build Time: 2014-11-12T14:32:18 + +NODEJS INFORMATION +================== +nodejs: v0.10.33 +grunt: 0.4.5 +grunt-audit: 1.0.0 +grunt-contrib-concat: 0.5.0 +grunt-contrib-copy: 0.7.0 +grunt-contrib-uglify: 0.6.0 +grunt-string-replace: 1.0.0 +web-component-tester: 1.6.0 + +REPO REVISIONS +============== +polymer-expressions: 1288fe573dc57cde304f66f0833d0644c766158c +polymer-gestures: 94660a514772e182d27f79c3d8d1bb88796a2327 +polymer: da75e633f39b7761494cc3139a60733c488b2215 + +BUILD HASHES +============ +dist/polymer.js: 59e0d3e669a3a1d163d8337766aa63bf809bfe79 +dist/polymer.min.js: a9145f911c5b9fecc0d4aa422ac658d1d462d15a +dist/layout.html: 348d358a91712ecc2f8811efa430fcd954b4590c \ No newline at end of file diff --git a/bower_components/polymer/layout.html b/bower_components/polymer/layout.html new file mode 100644 index 00000000..55d4d2f0 --- /dev/null +++ b/bower_components/polymer/layout.html @@ -0,0 +1,286 @@ + + \ No newline at end of file diff --git a/bower_components/polymer/polymer.html b/bower_components/polymer/polymer.html new file mode 100644 index 00000000..7e3d8f1e --- /dev/null +++ b/bower_components/polymer/polymer.html @@ -0,0 +1,12 @@ + + + + + diff --git a/bower_components/polymer/polymer.js b/bower_components/polymer/polymer.js new file mode 100644 index 00000000..b8b62b0a --- /dev/null +++ b/bower_components/polymer/polymer.js @@ -0,0 +1,11829 @@ +/** + * @license + * Copyright (c) 2014 The Polymer Project Authors. All rights reserved. + * This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt + * The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt + * The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt + * Code distributed by Google as part of the polymer project is also + * subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + */ +// @version 0.5.1 +window.PolymerGestures = {}; + +(function(scope) { + var HAS_FULL_PATH = false; + + // test for full event path support + var pathTest = document.createElement('meta'); + if (pathTest.createShadowRoot) { + var sr = pathTest.createShadowRoot(); + var s = document.createElement('span'); + sr.appendChild(s); + pathTest.addEventListener('testpath', function(ev) { + if (ev.path) { + // if the span is in the event path, then path[0] is the real source for all events + HAS_FULL_PATH = ev.path[0] === s; + } + ev.stopPropagation(); + }); + var ev = new CustomEvent('testpath', {bubbles: true}); + // must add node to DOM to trigger event listener + document.head.appendChild(pathTest); + s.dispatchEvent(ev); + pathTest.parentNode.removeChild(pathTest); + sr = s = null; + } + pathTest = null; + + var target = { + shadow: function(inEl) { + if (inEl) { + return inEl.shadowRoot || inEl.webkitShadowRoot; + } + }, + canTarget: function(shadow) { + return shadow && Boolean(shadow.elementFromPoint); + }, + targetingShadow: function(inEl) { + var s = this.shadow(inEl); + if (this.canTarget(s)) { + return s; + } + }, + olderShadow: function(shadow) { + var os = shadow.olderShadowRoot; + if (!os) { + var se = shadow.querySelector('shadow'); + if (se) { + os = se.olderShadowRoot; + } + } + return os; + }, + allShadows: function(element) { + var shadows = [], s = this.shadow(element); + while(s) { + shadows.push(s); + s = this.olderShadow(s); + } + return shadows; + }, + searchRoot: function(inRoot, x, y) { + var t, st, sr, os; + if (inRoot) { + t = inRoot.elementFromPoint(x, y); + if (t) { + // found element, check if it has a ShadowRoot + sr = this.targetingShadow(t); + } else if (inRoot !== document) { + // check for sibling roots + sr = this.olderShadow(inRoot); + } + // search other roots, fall back to light dom element + return this.searchRoot(sr, x, y) || t; + } + }, + owner: function(element) { + if (!element) { + return document; + } + var s = element; + // walk up until you hit the shadow root or document + while (s.parentNode) { + s = s.parentNode; + } + // the owner element is expected to be a Document or ShadowRoot + if (s.nodeType != Node.DOCUMENT_NODE && s.nodeType != Node.DOCUMENT_FRAGMENT_NODE) { + s = document; + } + return s; + }, + findTarget: function(inEvent) { + if (HAS_FULL_PATH && inEvent.path && inEvent.path.length) { + return inEvent.path[0]; + } + var x = inEvent.clientX, y = inEvent.clientY; + // if the listener is in the shadow root, it is much faster to start there + var s = this.owner(inEvent.target); + // if x, y is not in this root, fall back to document search + if (!s.elementFromPoint(x, y)) { + s = document; + } + return this.searchRoot(s, x, y); + }, + findTouchAction: function(inEvent) { + var n; + if (HAS_FULL_PATH && inEvent.path && inEvent.path.length) { + var path = inEvent.path; + for (var i = 0; i < path.length; i++) { + n = path[i]; + if (n.nodeType === Node.ELEMENT_NODE && n.hasAttribute('touch-action')) { + return n.getAttribute('touch-action'); + } + } + } else { + n = inEvent.target; + while(n) { + if (n.nodeType === Node.ELEMENT_NODE && n.hasAttribute('touch-action')) { + return n.getAttribute('touch-action'); + } + n = n.parentNode || n.host; + } + } + // auto is default + return "auto"; + }, + LCA: function(a, b) { + if (a === b) { + return a; + } + if (a && !b) { + return a; + } + if (b && !a) { + return b; + } + if (!b && !a) { + return document; + } + // fast case, a is a direct descendant of b or vice versa + if (a.contains && a.contains(b)) { + return a; + } + if (b.contains && b.contains(a)) { + return b; + } + var adepth = this.depth(a); + var bdepth = this.depth(b); + var d = adepth - bdepth; + if (d >= 0) { + a = this.walk(a, d); + } else { + b = this.walk(b, -d); + } + while (a && b && a !== b) { + a = a.parentNode || a.host; + b = b.parentNode || b.host; + } + return a; + }, + walk: function(n, u) { + for (var i = 0; n && (i < u); i++) { + n = n.parentNode || n.host; + } + return n; + }, + depth: function(n) { + var d = 0; + while(n) { + d++; + n = n.parentNode || n.host; + } + return d; + }, + deepContains: function(a, b) { + var common = this.LCA(a, b); + // if a is the common ancestor, it must "deeply" contain b + return common === a; + }, + insideNode: function(node, x, y) { + var rect = node.getBoundingClientRect(); + return (rect.left <= x) && (x <= rect.right) && (rect.top <= y) && (y <= rect.bottom); + }, + path: function(event) { + var p; + if (HAS_FULL_PATH && event.path && event.path.length) { + p = event.path; + } else { + p = []; + var n = this.findTarget(event); + while (n) { + p.push(n); + n = n.parentNode || n.host; + } + } + return p; + } + }; + scope.targetFinding = target; + /** + * Given an event, finds the "deepest" node that could have been the original target before ShadowDOM retargetting + * + * @param {Event} Event An event object with clientX and clientY properties + * @return {Element} The probable event origninator + */ + scope.findTarget = target.findTarget.bind(target); + /** + * Determines if the "container" node deeply contains the "containee" node, including situations where the "containee" is contained by one or more ShadowDOM + * roots. + * + * @param {Node} container + * @param {Node} containee + * @return {Boolean} + */ + scope.deepContains = target.deepContains.bind(target); + + /** + * Determines if the x/y position is inside the given node. + * + * Example: + * + * function upHandler(event) { + * var innode = PolymerGestures.insideNode(event.target, event.clientX, event.clientY); + * if (innode) { + * // wait for tap? + * } else { + * // tap will never happen + * } + * } + * + * @param {Node} node + * @param {Number} x Screen X position + * @param {Number} y screen Y position + * @return {Boolean} + */ + scope.insideNode = target.insideNode; + +})(window.PolymerGestures); + +(function() { + function shadowSelector(v) { + return 'html /deep/ ' + selector(v); + } + function selector(v) { + return '[touch-action="' + v + '"]'; + } + function rule(v) { + return '{ -ms-touch-action: ' + v + '; touch-action: ' + v + ';}'; + } + var attrib2css = [ + 'none', + 'auto', + 'pan-x', + 'pan-y', + { + rule: 'pan-x pan-y', + selectors: [ + 'pan-x pan-y', + 'pan-y pan-x' + ] + }, + 'manipulation' + ]; + var styles = ''; + // only install stylesheet if the browser has touch action support + var hasTouchAction = typeof document.head.style.touchAction === 'string'; + // only add shadow selectors if shadowdom is supported + var hasShadowRoot = !window.ShadowDOMPolyfill && document.head.createShadowRoot; + + if (hasTouchAction) { + attrib2css.forEach(function(r) { + if (String(r) === r) { + styles += selector(r) + rule(r) + '\n'; + if (hasShadowRoot) { + styles += shadowSelector(r) + rule(r) + '\n'; + } + } else { + styles += r.selectors.map(selector) + rule(r.rule) + '\n'; + if (hasShadowRoot) { + styles += r.selectors.map(shadowSelector) + rule(r.rule) + '\n'; + } + } + }); + + var el = document.createElement('style'); + el.textContent = styles; + document.head.appendChild(el); + } +})(); + +/** + * This is the constructor for new PointerEvents. + * + * New Pointer Events must be given a type, and an optional dictionary of + * initialization properties. + * + * Due to certain platform requirements, events returned from the constructor + * identify as MouseEvents. + * + * @constructor + * @param {String} inType The type of the event to create. + * @param {Object} [inDict] An optional dictionary of initial event properties. + * @return {Event} A new PointerEvent of type `inType` and initialized with properties from `inDict`. + */ +(function(scope) { + + var MOUSE_PROPS = [ + 'bubbles', + 'cancelable', + 'view', + 'detail', + 'screenX', + 'screenY', + 'clientX', + 'clientY', + 'ctrlKey', + 'altKey', + 'shiftKey', + 'metaKey', + 'button', + 'relatedTarget', + 'pageX', + 'pageY' + ]; + + var MOUSE_DEFAULTS = [ + false, + false, + null, + null, + 0, + 0, + 0, + 0, + false, + false, + false, + false, + 0, + null, + 0, + 0 + ]; + + var NOP_FACTORY = function(){ return function(){}; }; + + var eventFactory = { + // TODO(dfreedm): this is overridden by tap recognizer, needs review + preventTap: NOP_FACTORY, + makeBaseEvent: function(inType, inDict) { + var e = document.createEvent('Event'); + e.initEvent(inType, inDict.bubbles || false, inDict.cancelable || false); + e.preventTap = eventFactory.preventTap(e); + return e; + }, + makeGestureEvent: function(inType, inDict) { + inDict = inDict || Object.create(null); + + var e = this.makeBaseEvent(inType, inDict); + for (var i = 0, keys = Object.keys(inDict), k; i < keys.length; i++) { + k = keys[i]; + e[k] = inDict[k]; + } + return e; + }, + makePointerEvent: function(inType, inDict) { + inDict = inDict || Object.create(null); + + var e = this.makeBaseEvent(inType, inDict); + // define inherited MouseEvent properties + for(var i = 0, p; i < MOUSE_PROPS.length; i++) { + p = MOUSE_PROPS[i]; + e[p] = inDict[p] || MOUSE_DEFAULTS[i]; + } + e.buttons = inDict.buttons || 0; + + // Spec requires that pointers without pressure specified use 0.5 for down + // state and 0 for up state. + var pressure = 0; + if (inDict.pressure) { + pressure = inDict.pressure; + } else { + pressure = e.buttons ? 0.5 : 0; + } + + // add x/y properties aliased to clientX/Y + e.x = e.clientX; + e.y = e.clientY; + + // define the properties of the PointerEvent interface + e.pointerId = inDict.pointerId || 0; + e.width = inDict.width || 0; + e.height = inDict.height || 0; + e.pressure = pressure; + e.tiltX = inDict.tiltX || 0; + e.tiltY = inDict.tiltY || 0; + e.pointerType = inDict.pointerType || ''; + e.hwTimestamp = inDict.hwTimestamp || 0; + e.isPrimary = inDict.isPrimary || false; + e._source = inDict._source || ''; + return e; + } + }; + + scope.eventFactory = eventFactory; +})(window.PolymerGestures); + +/** + * This module implements an map of pointer states + */ +(function(scope) { + var USE_MAP = window.Map && window.Map.prototype.forEach; + var POINTERS_FN = function(){ return this.size; }; + function PointerMap() { + if (USE_MAP) { + var m = new Map(); + m.pointers = POINTERS_FN; + return m; + } else { + this.keys = []; + this.values = []; + } + } + + PointerMap.prototype = { + set: function(inId, inEvent) { + var i = this.keys.indexOf(inId); + if (i > -1) { + this.values[i] = inEvent; + } else { + this.keys.push(inId); + this.values.push(inEvent); + } + }, + has: function(inId) { + return this.keys.indexOf(inId) > -1; + }, + 'delete': function(inId) { + var i = this.keys.indexOf(inId); + if (i > -1) { + this.keys.splice(i, 1); + this.values.splice(i, 1); + } + }, + get: function(inId) { + var i = this.keys.indexOf(inId); + return this.values[i]; + }, + clear: function() { + this.keys.length = 0; + this.values.length = 0; + }, + // return value, key, map + forEach: function(callback, thisArg) { + this.values.forEach(function(v, i) { + callback.call(thisArg, v, this.keys[i], this); + }, this); + }, + pointers: function() { + return this.keys.length; + } + }; + + scope.PointerMap = PointerMap; +})(window.PolymerGestures); + +(function(scope) { + var CLONE_PROPS = [ + // MouseEvent + 'bubbles', + 'cancelable', + 'view', + 'detail', + 'screenX', + 'screenY', + 'clientX', + 'clientY', + 'ctrlKey', + 'altKey', + 'shiftKey', + 'metaKey', + 'button', + 'relatedTarget', + // DOM Level 3 + 'buttons', + // PointerEvent + 'pointerId', + 'width', + 'height', + 'pressure', + 'tiltX', + 'tiltY', + 'pointerType', + 'hwTimestamp', + 'isPrimary', + // event instance + 'type', + 'target', + 'currentTarget', + 'which', + 'pageX', + 'pageY', + 'timeStamp', + // gesture addons + 'preventTap', + 'tapPrevented', + '_source' + ]; + + var CLONE_DEFAULTS = [ + // MouseEvent + false, + false, + null, + null, + 0, + 0, + 0, + 0, + false, + false, + false, + false, + 0, + null, + // DOM Level 3 + 0, + // PointerEvent + 0, + 0, + 0, + 0, + 0, + 0, + '', + 0, + false, + // event instance + '', + null, + null, + 0, + 0, + 0, + 0, + function(){}, + false + ]; + + var HAS_SVG_INSTANCE = (typeof SVGElementInstance !== 'undefined'); + + var eventFactory = scope.eventFactory; + + // set of recognizers to run for the currently handled event + var currentGestures; + + /** + * This module is for normalizing events. Mouse and Touch events will be + * collected here, and fire PointerEvents that have the same semantics, no + * matter the source. + * Events fired: + * - pointerdown: a pointing is added + * - pointerup: a pointer is removed + * - pointermove: a pointer is moved + * - pointerover: a pointer crosses into an element + * - pointerout: a pointer leaves an element + * - pointercancel: a pointer will no longer generate events + */ + var dispatcher = { + IS_IOS: false, + pointermap: new scope.PointerMap(), + requiredGestures: new scope.PointerMap(), + eventMap: Object.create(null), + // Scope objects for native events. + // This exists for ease of testing. + eventSources: Object.create(null), + eventSourceList: [], + gestures: [], + // map gesture event -> {listeners: int, index: gestures[int]} + dependencyMap: { + // make sure down and up are in the map to trigger "register" + down: {listeners: 0, index: -1}, + up: {listeners: 0, index: -1} + }, + gestureQueue: [], + /** + * Add a new event source that will generate pointer events. + * + * `inSource` must contain an array of event names named `events`, and + * functions with the names specified in the `events` array. + * @param {string} name A name for the event source + * @param {Object} source A new source of platform events. + */ + registerSource: function(name, source) { + var s = source; + var newEvents = s.events; + if (newEvents) { + newEvents.forEach(function(e) { + if (s[e]) { + this.eventMap[e] = s[e].bind(s); + } + }, this); + this.eventSources[name] = s; + this.eventSourceList.push(s); + } + }, + registerGesture: function(name, source) { + var obj = Object.create(null); + obj.listeners = 0; + obj.index = this.gestures.length; + for (var i = 0, g; i < source.exposes.length; i++) { + g = source.exposes[i].toLowerCase(); + this.dependencyMap[g] = obj; + } + this.gestures.push(source); + }, + register: function(element, initial) { + var l = this.eventSourceList.length; + for (var i = 0, es; (i < l) && (es = this.eventSourceList[i]); i++) { + // call eventsource register + es.register.call(es, element, initial); + } + }, + unregister: function(element) { + var l = this.eventSourceList.length; + for (var i = 0, es; (i < l) && (es = this.eventSourceList[i]); i++) { + // call eventsource register + es.unregister.call(es, element); + } + }, + // EVENTS + down: function(inEvent) { + this.requiredGestures.set(inEvent.pointerId, currentGestures); + this.fireEvent('down', inEvent); + }, + move: function(inEvent) { + // pipe move events into gesture queue directly + inEvent.type = 'move'; + this.fillGestureQueue(inEvent); + }, + up: function(inEvent) { + this.fireEvent('up', inEvent); + this.requiredGestures.delete(inEvent.pointerId); + }, + cancel: function(inEvent) { + inEvent.tapPrevented = true; + this.fireEvent('up', inEvent); + this.requiredGestures.delete(inEvent.pointerId); + }, + addGestureDependency: function(node, currentGestures) { + var gesturesWanted = node._pgEvents; + if (gesturesWanted && currentGestures) { + var gk = Object.keys(gesturesWanted); + for (var i = 0, r, ri, g; i < gk.length; i++) { + // gesture + g = gk[i]; + if (gesturesWanted[g] > 0) { + // lookup gesture recognizer + r = this.dependencyMap[g]; + // recognizer index + ri = r ? r.index : -1; + currentGestures[ri] = true; + } + } + } + }, + // LISTENER LOGIC + eventHandler: function(inEvent) { + // This is used to prevent multiple dispatch of events from + // platform events. This can happen when two elements in different scopes + // are set up to create pointer events, which is relevant to Shadow DOM. + + var type = inEvent.type; + + // only generate the list of desired events on "down" + if (type === 'touchstart' || type === 'mousedown' || type === 'pointerdown' || type === 'MSPointerDown') { + if (!inEvent._handledByPG) { + currentGestures = {}; + } + + // in IOS mode, there is only a listener on the document, so this is not re-entrant + if (this.IS_IOS) { + var ev = inEvent; + if (type === 'touchstart') { + var ct = inEvent.changedTouches[0]; + // set up a fake event to give to the path builder + ev = {target: inEvent.target, clientX: ct.clientX, clientY: ct.clientY, path: inEvent.path}; + } + // use event path if available, otherwise build a path from target finding + var nodes = inEvent.path || scope.targetFinding.path(ev); + for (var i = 0, n; i < nodes.length; i++) { + n = nodes[i]; + this.addGestureDependency(n, currentGestures); + } + } else { + this.addGestureDependency(inEvent.currentTarget, currentGestures); + } + } + + if (inEvent._handledByPG) { + return; + } + var fn = this.eventMap && this.eventMap[type]; + if (fn) { + fn(inEvent); + } + inEvent._handledByPG = true; + }, + // set up event listeners + listen: function(target, events) { + for (var i = 0, l = events.length, e; (i < l) && (e = events[i]); i++) { + this.addEvent(target, e); + } + }, + // remove event listeners + unlisten: function(target, events) { + for (var i = 0, l = events.length, e; (i < l) && (e = events[i]); i++) { + this.removeEvent(target, e); + } + }, + addEvent: function(target, eventName) { + target.addEventListener(eventName, this.boundHandler); + }, + removeEvent: function(target, eventName) { + target.removeEventListener(eventName, this.boundHandler); + }, + // EVENT CREATION AND TRACKING + /** + * Creates a new Event of type `inType`, based on the information in + * `inEvent`. + * + * @param {string} inType A string representing the type of event to create + * @param {Event} inEvent A platform event with a target + * @return {Event} A PointerEvent of type `inType` + */ + makeEvent: function(inType, inEvent) { + var e = eventFactory.makePointerEvent(inType, inEvent); + e.preventDefault = inEvent.preventDefault; + e.tapPrevented = inEvent.tapPrevented; + e._target = e._target || inEvent.target; + return e; + }, + // make and dispatch an event in one call + fireEvent: function(inType, inEvent) { + var e = this.makeEvent(inType, inEvent); + return this.dispatchEvent(e); + }, + /** + * Returns a snapshot of inEvent, with writable properties. + * + * @param {Event} inEvent An event that contains properties to copy. + * @return {Object} An object containing shallow copies of `inEvent`'s + * properties. + */ + cloneEvent: function(inEvent) { + var eventCopy = Object.create(null), p; + for (var i = 0; i < CLONE_PROPS.length; i++) { + p = CLONE_PROPS[i]; + eventCopy[p] = inEvent[p] || CLONE_DEFAULTS[i]; + // Work around SVGInstanceElement shadow tree + // Return the element that is represented by the instance for Safari, Chrome, IE. + // This is the behavior implemented by Firefox. + if (p === 'target' || p === 'relatedTarget') { + if (HAS_SVG_INSTANCE && eventCopy[p] instanceof SVGElementInstance) { + eventCopy[p] = eventCopy[p].correspondingUseElement; + } + } + } + // keep the semantics of preventDefault + eventCopy.preventDefault = function() { + inEvent.preventDefault(); + }; + return eventCopy; + }, + /** + * Dispatches the event to its target. + * + * @param {Event} inEvent The event to be dispatched. + * @return {Boolean} True if an event handler returns true, false otherwise. + */ + dispatchEvent: function(inEvent) { + var t = inEvent._target; + if (t) { + t.dispatchEvent(inEvent); + // clone the event for the gesture system to process + // clone after dispatch to pick up gesture prevention code + var clone = this.cloneEvent(inEvent); + clone.target = t; + this.fillGestureQueue(clone); + } + }, + gestureTrigger: function() { + // process the gesture queue + for (var i = 0, e, rg; i < this.gestureQueue.length; i++) { + e = this.gestureQueue[i]; + rg = e._requiredGestures; + if (rg) { + for (var j = 0, g, fn; j < this.gestures.length; j++) { + // only run recognizer if an element in the source event's path is listening for those gestures + if (rg[j]) { + g = this.gestures[j]; + fn = g[e.type]; + if (fn) { + fn.call(g, e); + } + } + } + } + } + this.gestureQueue.length = 0; + }, + fillGestureQueue: function(ev) { + // only trigger the gesture queue once + if (!this.gestureQueue.length) { + requestAnimationFrame(this.boundGestureTrigger); + } + ev._requiredGestures = this.requiredGestures.get(ev.pointerId); + this.gestureQueue.push(ev); + } + }; + dispatcher.boundHandler = dispatcher.eventHandler.bind(dispatcher); + dispatcher.boundGestureTrigger = dispatcher.gestureTrigger.bind(dispatcher); + scope.dispatcher = dispatcher; + + /** + * Listen for `gesture` on `node` with the `handler` function + * + * If `handler` is the first listener for `gesture`, the underlying gesture recognizer is then enabled. + * + * @param {Element} node + * @param {string} gesture + * @return Boolean `gesture` is a valid gesture + */ + scope.activateGesture = function(node, gesture) { + var g = gesture.toLowerCase(); + var dep = dispatcher.dependencyMap[g]; + if (dep) { + var recognizer = dispatcher.gestures[dep.index]; + if (!node._pgListeners) { + dispatcher.register(node); + node._pgListeners = 0; + } + // TODO(dfreedm): re-evaluate bookkeeping to avoid using attributes + if (recognizer) { + var touchAction = recognizer.defaultActions && recognizer.defaultActions[g]; + var actionNode; + switch(node.nodeType) { + case Node.ELEMENT_NODE: + actionNode = node; + break; + case Node.DOCUMENT_FRAGMENT_NODE: + actionNode = node.host; + break; + default: + actionNode = null; + break; + } + if (touchAction && actionNode && !actionNode.hasAttribute('touch-action')) { + actionNode.setAttribute('touch-action', touchAction); + } + } + if (!node._pgEvents) { + node._pgEvents = {}; + } + node._pgEvents[g] = (node._pgEvents[g] || 0) + 1; + node._pgListeners++; + } + return Boolean(dep); + }; + + /** + * + * Listen for `gesture` from `node` with `handler` function. + * + * @param {Element} node + * @param {string} gesture + * @param {Function} handler + * @param {Boolean} capture + */ + scope.addEventListener = function(node, gesture, handler, capture) { + if (handler) { + scope.activateGesture(node, gesture); + node.addEventListener(gesture, handler, capture); + } + }; + + /** + * Tears down the gesture configuration for `node` + * + * If `handler` is the last listener for `gesture`, the underlying gesture recognizer is disabled. + * + * @param {Element} node + * @param {string} gesture + * @return Boolean `gesture` is a valid gesture + */ + scope.deactivateGesture = function(node, gesture) { + var g = gesture.toLowerCase(); + var dep = dispatcher.dependencyMap[g]; + if (dep) { + if (node._pgListeners > 0) { + node._pgListeners--; + } + if (node._pgListeners === 0) { + dispatcher.unregister(node); + } + if (node._pgEvents) { + if (node._pgEvents[g] > 0) { + node._pgEvents[g]--; + } else { + node._pgEvents[g] = 0; + } + } + } + return Boolean(dep); + }; + + /** + * Stop listening for `gesture` from `node` with `handler` function. + * + * @param {Element} node + * @param {string} gesture + * @param {Function} handler + * @param {Boolean} capture + */ + scope.removeEventListener = function(node, gesture, handler, capture) { + if (handler) { + scope.deactivateGesture(node, gesture); + node.removeEventListener(gesture, handler, capture); + } + }; +})(window.PolymerGestures); + +(function (scope) { + var dispatcher = scope.dispatcher; + var pointermap = dispatcher.pointermap; + // radius around touchend that swallows mouse events + var DEDUP_DIST = 25; + + var WHICH_TO_BUTTONS = [0, 1, 4, 2]; + + var CURRENT_BUTTONS = 0; + var HAS_BUTTONS = false; + try { + HAS_BUTTONS = new MouseEvent('test', {buttons: 1}).buttons === 1; + } catch (e) {} + + // handler block for native mouse events + var mouseEvents = { + POINTER_ID: 1, + POINTER_TYPE: 'mouse', + events: [ + 'mousedown', + 'mousemove', + 'mouseup' + ], + exposes: [ + 'down', + 'up', + 'move' + ], + register: function(target) { + dispatcher.listen(target, this.events); + }, + unregister: function(target) { + if (target === document) { + return; + } + dispatcher.unlisten(target, this.events); + }, + lastTouches: [], + // collide with the global mouse listener + isEventSimulatedFromTouch: function(inEvent) { + var lts = this.lastTouches; + var x = inEvent.clientX, y = inEvent.clientY; + for (var i = 0, l = lts.length, t; i < l && (t = lts[i]); i++) { + // simulated mouse events will be swallowed near a primary touchend + var dx = Math.abs(x - t.x), dy = Math.abs(y - t.y); + if (dx <= DEDUP_DIST && dy <= DEDUP_DIST) { + return true; + } + } + }, + prepareEvent: function(inEvent) { + var e = dispatcher.cloneEvent(inEvent); + e.pointerId = this.POINTER_ID; + e.isPrimary = true; + e.pointerType = this.POINTER_TYPE; + e._source = 'mouse'; + if (!HAS_BUTTONS) { + var type = inEvent.type; + var bit = WHICH_TO_BUTTONS[inEvent.which] || 0; + if (type === 'mousedown') { + CURRENT_BUTTONS |= bit; + } else if (type === 'mouseup') { + CURRENT_BUTTONS &= ~bit; + } + e.buttons = CURRENT_BUTTONS; + } + return e; + }, + mousedown: function(inEvent) { + if (!this.isEventSimulatedFromTouch(inEvent)) { + var p = pointermap.has(this.POINTER_ID); + var e = this.prepareEvent(inEvent); + e.target = scope.findTarget(inEvent); + pointermap.set(this.POINTER_ID, e.target); + dispatcher.down(e); + } + }, + mousemove: function(inEvent) { + if (!this.isEventSimulatedFromTouch(inEvent)) { + var target = pointermap.get(this.POINTER_ID); + if (target) { + var e = this.prepareEvent(inEvent); + e.target = target; + // handle case where we missed a mouseup + if ((HAS_BUTTONS ? e.buttons : e.which) === 0) { + if (!HAS_BUTTONS) { + CURRENT_BUTTONS = e.buttons = 0; + } + dispatcher.cancel(e); + this.cleanupMouse(e.buttons); + } else { + dispatcher.move(e); + } + } + } + }, + mouseup: function(inEvent) { + if (!this.isEventSimulatedFromTouch(inEvent)) { + var e = this.prepareEvent(inEvent); + e.relatedTarget = scope.findTarget(inEvent); + e.target = pointermap.get(this.POINTER_ID); + dispatcher.up(e); + this.cleanupMouse(e.buttons); + } + }, + cleanupMouse: function(buttons) { + if (buttons === 0) { + pointermap.delete(this.POINTER_ID); + } + } + }; + + scope.mouseEvents = mouseEvents; +})(window.PolymerGestures); + +(function(scope) { + var dispatcher = scope.dispatcher; + var allShadows = scope.targetFinding.allShadows.bind(scope.targetFinding); + var pointermap = dispatcher.pointermap; + var touchMap = Array.prototype.map.call.bind(Array.prototype.map); + // This should be long enough to ignore compat mouse events made by touch + var DEDUP_TIMEOUT = 2500; + var DEDUP_DIST = 25; + var CLICK_COUNT_TIMEOUT = 200; + var HYSTERESIS = 20; + var ATTRIB = 'touch-action'; + // TODO(dfreedm): disable until http://crbug.com/399765 is resolved + // var HAS_TOUCH_ACTION = ATTRIB in document.head.style; + var HAS_TOUCH_ACTION = false; + + // handler block for native touch events + var touchEvents = { + IS_IOS: false, + events: [ + 'touchstart', + 'touchmove', + 'touchend', + 'touchcancel' + ], + exposes: [ + 'down', + 'up', + 'move' + ], + register: function(target, initial) { + if (this.IS_IOS ? initial : !initial) { + dispatcher.listen(target, this.events); + } + }, + unregister: function(target) { + if (!this.IS_IOS) { + dispatcher.unlisten(target, this.events); + } + }, + scrollTypes: { + EMITTER: 'none', + XSCROLLER: 'pan-x', + YSCROLLER: 'pan-y', + }, + touchActionToScrollType: function(touchAction) { + var t = touchAction; + var st = this.scrollTypes; + if (t === st.EMITTER) { + return 'none'; + } else if (t === st.XSCROLLER) { + return 'X'; + } else if (t === st.YSCROLLER) { + return 'Y'; + } else { + return 'XY'; + } + }, + POINTER_TYPE: 'touch', + firstTouch: null, + isPrimaryTouch: function(inTouch) { + return this.firstTouch === inTouch.identifier; + }, + setPrimaryTouch: function(inTouch) { + // set primary touch if there no pointers, or the only pointer is the mouse + if (pointermap.pointers() === 0 || (pointermap.pointers() === 1 && pointermap.has(1))) { + this.firstTouch = inTouch.identifier; + this.firstXY = {X: inTouch.clientX, Y: inTouch.clientY}; + this.firstTarget = inTouch.target; + this.scrolling = null; + this.cancelResetClickCount(); + } + }, + removePrimaryPointer: function(inPointer) { + if (inPointer.isPrimary) { + this.firstTouch = null; + this.firstXY = null; + this.resetClickCount(); + } + }, + clickCount: 0, + resetId: null, + resetClickCount: function() { + var fn = function() { + this.clickCount = 0; + this.resetId = null; + }.bind(this); + this.resetId = setTimeout(fn, CLICK_COUNT_TIMEOUT); + }, + cancelResetClickCount: function() { + if (this.resetId) { + clearTimeout(this.resetId); + } + }, + typeToButtons: function(type) { + var ret = 0; + if (type === 'touchstart' || type === 'touchmove') { + ret = 1; + } + return ret; + }, + findTarget: function(touch, id) { + if (this.currentTouchEvent.type === 'touchstart') { + if (this.isPrimaryTouch(touch)) { + var fastPath = { + clientX: touch.clientX, + clientY: touch.clientY, + path: this.currentTouchEvent.path, + target: this.currentTouchEvent.target + }; + return scope.findTarget(fastPath); + } else { + return scope.findTarget(touch); + } + } + // reuse target we found in touchstart + return pointermap.get(id); + }, + touchToPointer: function(inTouch) { + var cte = this.currentTouchEvent; + var e = dispatcher.cloneEvent(inTouch); + // Spec specifies that pointerId 1 is reserved for Mouse. + // Touch identifiers can start at 0. + // Add 2 to the touch identifier for compatibility. + var id = e.pointerId = inTouch.identifier + 2; + e.target = this.findTarget(inTouch, id); + e.bubbles = true; + e.cancelable = true; + e.detail = this.clickCount; + e.buttons = this.typeToButtons(cte.type); + e.width = inTouch.webkitRadiusX || inTouch.radiusX || 0; + e.height = inTouch.webkitRadiusY || inTouch.radiusY || 0; + e.pressure = inTouch.webkitForce || inTouch.force || 0.5; + e.isPrimary = this.isPrimaryTouch(inTouch); + e.pointerType = this.POINTER_TYPE; + e._source = 'touch'; + // forward touch preventDefaults + var self = this; + e.preventDefault = function() { + self.scrolling = false; + self.firstXY = null; + cte.preventDefault(); + }; + return e; + }, + processTouches: function(inEvent, inFunction) { + var tl = inEvent.changedTouches; + this.currentTouchEvent = inEvent; + for (var i = 0, t, p; i < tl.length; i++) { + t = tl[i]; + p = this.touchToPointer(t); + if (inEvent.type === 'touchstart') { + pointermap.set(p.pointerId, p.target); + } + if (pointermap.has(p.pointerId)) { + inFunction.call(this, p); + } + if (inEvent.type === 'touchend' || inEvent._cancel) { + this.cleanUpPointer(p); + } + } + }, + // For single axis scrollers, determines whether the element should emit + // pointer events or behave as a scroller + shouldScroll: function(inEvent) { + if (this.firstXY) { + var ret; + var touchAction = scope.targetFinding.findTouchAction(inEvent); + var scrollAxis = this.touchActionToScrollType(touchAction); + if (scrollAxis === 'none') { + // this element is a touch-action: none, should never scroll + ret = false; + } else if (scrollAxis === 'XY') { + // this element should always scroll + ret = true; + } else { + var t = inEvent.changedTouches[0]; + // check the intended scroll axis, and other axis + var a = scrollAxis; + var oa = scrollAxis === 'Y' ? 'X' : 'Y'; + var da = Math.abs(t['client' + a] - this.firstXY[a]); + var doa = Math.abs(t['client' + oa] - this.firstXY[oa]); + // if delta in the scroll axis > delta other axis, scroll instead of + // making events + ret = da >= doa; + } + return ret; + } + }, + findTouch: function(inTL, inId) { + for (var i = 0, l = inTL.length, t; i < l && (t = inTL[i]); i++) { + if (t.identifier === inId) { + return true; + } + } + }, + // In some instances, a touchstart can happen without a touchend. This + // leaves the pointermap in a broken state. + // Therefore, on every touchstart, we remove the touches that did not fire a + // touchend event. + // To keep state globally consistent, we fire a + // pointercancel for this "abandoned" touch + vacuumTouches: function(inEvent) { + var tl = inEvent.touches; + // pointermap.pointers() should be < tl.length here, as the touchstart has not + // been processed yet. + if (pointermap.pointers() >= tl.length) { + var d = []; + pointermap.forEach(function(value, key) { + // Never remove pointerId == 1, which is mouse. + // Touch identifiers are 2 smaller than their pointerId, which is the + // index in pointermap. + if (key !== 1 && !this.findTouch(tl, key - 2)) { + var p = value; + d.push(p); + } + }, this); + d.forEach(function(p) { + this.cancel(p); + pointermap.delete(p.pointerId); + }); + } + }, + touchstart: function(inEvent) { + this.vacuumTouches(inEvent); + this.setPrimaryTouch(inEvent.changedTouches[0]); + this.dedupSynthMouse(inEvent); + if (!this.scrolling) { + this.clickCount++; + this.processTouches(inEvent, this.down); + } + }, + down: function(inPointer) { + dispatcher.down(inPointer); + }, + touchmove: function(inEvent) { + if (HAS_TOUCH_ACTION) { + // touchevent.cancelable == false is sent when the page is scrolling under native Touch Action in Chrome 36 + // https://groups.google.com/a/chromium.org/d/msg/input-dev/wHnyukcYBcA/b9kmtwM1jJQJ + if (inEvent.cancelable) { + this.processTouches(inEvent, this.move); + } + } else { + if (!this.scrolling) { + if (this.scrolling === null && this.shouldScroll(inEvent)) { + this.scrolling = true; + } else { + this.scrolling = false; + inEvent.preventDefault(); + this.processTouches(inEvent, this.move); + } + } else if (this.firstXY) { + var t = inEvent.changedTouches[0]; + var dx = t.clientX - this.firstXY.X; + var dy = t.clientY - this.firstXY.Y; + var dd = Math.sqrt(dx * dx + dy * dy); + if (dd >= HYSTERESIS) { + this.touchcancel(inEvent); + this.scrolling = true; + this.firstXY = null; + } + } + } + }, + move: function(inPointer) { + dispatcher.move(inPointer); + }, + touchend: function(inEvent) { + this.dedupSynthMouse(inEvent); + this.processTouches(inEvent, this.up); + }, + up: function(inPointer) { + inPointer.relatedTarget = scope.findTarget(inPointer); + dispatcher.up(inPointer); + }, + cancel: function(inPointer) { + dispatcher.cancel(inPointer); + }, + touchcancel: function(inEvent) { + inEvent._cancel = true; + this.processTouches(inEvent, this.cancel); + }, + cleanUpPointer: function(inPointer) { + pointermap['delete'](inPointer.pointerId); + this.removePrimaryPointer(inPointer); + }, + // prevent synth mouse events from creating pointer events + dedupSynthMouse: function(inEvent) { + var lts = scope.mouseEvents.lastTouches; + var t = inEvent.changedTouches[0]; + // only the primary finger will synth mouse events + if (this.isPrimaryTouch(t)) { + // remember x/y of last touch + var lt = {x: t.clientX, y: t.clientY}; + lts.push(lt); + var fn = (function(lts, lt){ + var i = lts.indexOf(lt); + if (i > -1) { + lts.splice(i, 1); + } + }).bind(null, lts, lt); + setTimeout(fn, DEDUP_TIMEOUT); + } + } + }; + + // prevent "ghost clicks" that come from elements that were removed in a touch handler + var STOP_PROP_FN = Event.prototype.stopImmediatePropagation || Event.prototype.stopPropagation; + document.addEventListener('click', function(ev) { + var x = ev.clientX, y = ev.clientY; + // check if a click is within DEDUP_DIST px radius of the touchstart + var closeTo = function(touch) { + var dx = Math.abs(x - touch.x), dy = Math.abs(y - touch.y); + return (dx <= DEDUP_DIST && dy <= DEDUP_DIST); + }; + // if click coordinates are close to touch coordinates, assume the click came from a touch + var wasTouched = scope.mouseEvents.lastTouches.some(closeTo); + // if the click came from touch, and the touchstart target is not in the path of the click event, + // then the touchstart target was probably removed, and the click should be "busted" + var path = scope.targetFinding.path(ev); + if (wasTouched) { + for (var i = 0; i < path.length; i++) { + if (path[i] === touchEvents.firstTarget) { + return; + } + } + ev.preventDefault(); + STOP_PROP_FN.call(ev); + } + }, true); + + scope.touchEvents = touchEvents; +})(window.PolymerGestures); + +(function(scope) { + var dispatcher = scope.dispatcher; + var pointermap = dispatcher.pointermap; + var HAS_BITMAP_TYPE = window.MSPointerEvent && typeof window.MSPointerEvent.MSPOINTER_TYPE_MOUSE === 'number'; + var msEvents = { + events: [ + 'MSPointerDown', + 'MSPointerMove', + 'MSPointerUp', + 'MSPointerCancel', + ], + register: function(target) { + dispatcher.listen(target, this.events); + }, + unregister: function(target) { + if (target === document) { + return; + } + dispatcher.unlisten(target, this.events); + }, + POINTER_TYPES: [ + '', + 'unavailable', + 'touch', + 'pen', + 'mouse' + ], + prepareEvent: function(inEvent) { + var e = inEvent; + e = dispatcher.cloneEvent(inEvent); + if (HAS_BITMAP_TYPE) { + e.pointerType = this.POINTER_TYPES[inEvent.pointerType]; + } + e._source = 'ms'; + return e; + }, + cleanup: function(id) { + pointermap['delete'](id); + }, + MSPointerDown: function(inEvent) { + var e = this.prepareEvent(inEvent); + e.target = scope.findTarget(inEvent); + pointermap.set(inEvent.pointerId, e.target); + dispatcher.down(e); + }, + MSPointerMove: function(inEvent) { + var target = pointermap.get(inEvent.pointerId); + if (target) { + var e = this.prepareEvent(inEvent); + e.target = target; + dispatcher.move(e); + } + }, + MSPointerUp: function(inEvent) { + var e = this.prepareEvent(inEvent); + e.relatedTarget = scope.findTarget(inEvent); + e.target = pointermap.get(e.pointerId); + dispatcher.up(e); + this.cleanup(inEvent.pointerId); + }, + MSPointerCancel: function(inEvent) { + var e = this.prepareEvent(inEvent); + e.relatedTarget = scope.findTarget(inEvent); + e.target = pointermap.get(e.pointerId); + dispatcher.cancel(e); + this.cleanup(inEvent.pointerId); + } + }; + + scope.msEvents = msEvents; +})(window.PolymerGestures); + +(function(scope) { + var dispatcher = scope.dispatcher; + var pointermap = dispatcher.pointermap; + var pointerEvents = { + events: [ + 'pointerdown', + 'pointermove', + 'pointerup', + 'pointercancel' + ], + prepareEvent: function(inEvent) { + var e = dispatcher.cloneEvent(inEvent); + e._source = 'pointer'; + return e; + }, + register: function(target) { + dispatcher.listen(target, this.events); + }, + unregister: function(target) { + if (target === document) { + return; + } + dispatcher.unlisten(target, this.events); + }, + cleanup: function(id) { + pointermap['delete'](id); + }, + pointerdown: function(inEvent) { + var e = this.prepareEvent(inEvent); + e.target = scope.findTarget(inEvent); + pointermap.set(e.pointerId, e.target); + dispatcher.down(e); + }, + pointermove: function(inEvent) { + var target = pointermap.get(inEvent.pointerId); + if (target) { + var e = this.prepareEvent(inEvent); + e.target = target; + dispatcher.move(e); + } + }, + pointerup: function(inEvent) { + var e = this.prepareEvent(inEvent); + e.relatedTarget = scope.findTarget(inEvent); + e.target = pointermap.get(e.pointerId); + dispatcher.up(e); + this.cleanup(inEvent.pointerId); + }, + pointercancel: function(inEvent) { + var e = this.prepareEvent(inEvent); + e.relatedTarget = scope.findTarget(inEvent); + e.target = pointermap.get(e.pointerId); + dispatcher.cancel(e); + this.cleanup(inEvent.pointerId); + } + }; + + scope.pointerEvents = pointerEvents; +})(window.PolymerGestures); + +/** + * This module contains the handlers for native platform events. + * From here, the dispatcher is called to create unified pointer events. + * Included are touch events (v1), mouse events, and MSPointerEvents. + */ +(function(scope) { + + var dispatcher = scope.dispatcher; + var nav = window.navigator; + + if (window.PointerEvent) { + dispatcher.registerSource('pointer', scope.pointerEvents); + } else if (nav.msPointerEnabled) { + dispatcher.registerSource('ms', scope.msEvents); + } else { + dispatcher.registerSource('mouse', scope.mouseEvents); + if (window.ontouchstart !== undefined) { + dispatcher.registerSource('touch', scope.touchEvents); + } + } + + // Work around iOS bugs https://bugs.webkit.org/show_bug.cgi?id=135628 and https://bugs.webkit.org/show_bug.cgi?id=136506 + var ua = navigator.userAgent; + var IS_IOS = ua.match(/iPad|iPhone|iPod/) && 'ontouchstart' in window; + + dispatcher.IS_IOS = IS_IOS; + scope.touchEvents.IS_IOS = IS_IOS; + + dispatcher.register(document, true); +})(window.PolymerGestures); + +/** + * This event denotes the beginning of a series of tracking events. + * + * @module PointerGestures + * @submodule Events + * @class trackstart + */ +/** + * Pixels moved in the x direction since trackstart. + * @type Number + * @property dx + */ +/** + * Pixes moved in the y direction since trackstart. + * @type Number + * @property dy + */ +/** + * Pixels moved in the x direction since the last track. + * @type Number + * @property ddx + */ +/** + * Pixles moved in the y direction since the last track. + * @type Number + * @property ddy + */ +/** + * The clientX position of the track gesture. + * @type Number + * @property clientX + */ +/** + * The clientY position of the track gesture. + * @type Number + * @property clientY + */ +/** + * The pageX position of the track gesture. + * @type Number + * @property pageX + */ +/** + * The pageY position of the track gesture. + * @type Number + * @property pageY + */ +/** + * The screenX position of the track gesture. + * @type Number + * @property screenX + */ +/** + * The screenY position of the track gesture. + * @type Number + * @property screenY + */ +/** + * The last x axis direction of the pointer. + * @type Number + * @property xDirection + */ +/** + * The last y axis direction of the pointer. + * @type Number + * @property yDirection + */ +/** + * A shared object between all tracking events. + * @type Object + * @property trackInfo + */ +/** + * The element currently under the pointer. + * @type Element + * @property relatedTarget + */ +/** + * The type of pointer that make the track gesture. + * @type String + * @property pointerType + */ +/** + * + * This event fires for all pointer movement being tracked. + * + * @class track + * @extends trackstart + */ +/** + * This event fires when the pointer is no longer being tracked. + * + * @class trackend + * @extends trackstart + */ + + (function(scope) { + var dispatcher = scope.dispatcher; + var eventFactory = scope.eventFactory; + var pointermap = new scope.PointerMap(); + var track = { + events: [ + 'down', + 'move', + 'up', + ], + exposes: [ + 'trackstart', + 'track', + 'trackx', + 'tracky', + 'trackend' + ], + defaultActions: { + 'track': 'none', + 'trackx': 'pan-y', + 'tracky': 'pan-x' + }, + WIGGLE_THRESHOLD: 4, + clampDir: function(inDelta) { + return inDelta > 0 ? 1 : -1; + }, + calcPositionDelta: function(inA, inB) { + var x = 0, y = 0; + if (inA && inB) { + x = inB.pageX - inA.pageX; + y = inB.pageY - inA.pageY; + } + return {x: x, y: y}; + }, + fireTrack: function(inType, inEvent, inTrackingData) { + var t = inTrackingData; + var d = this.calcPositionDelta(t.downEvent, inEvent); + var dd = this.calcPositionDelta(t.lastMoveEvent, inEvent); + if (dd.x) { + t.xDirection = this.clampDir(dd.x); + } else if (inType === 'trackx') { + return; + } + if (dd.y) { + t.yDirection = this.clampDir(dd.y); + } else if (inType === 'tracky') { + return; + } + var gestureProto = { + bubbles: true, + cancelable: true, + trackInfo: t.trackInfo, + relatedTarget: inEvent.relatedTarget, + pointerType: inEvent.pointerType, + pointerId: inEvent.pointerId, + _source: 'track' + }; + if (inType !== 'tracky') { + gestureProto.x = inEvent.x; + gestureProto.dx = d.x; + gestureProto.ddx = dd.x; + gestureProto.clientX = inEvent.clientX; + gestureProto.pageX = inEvent.pageX; + gestureProto.screenX = inEvent.screenX; + gestureProto.xDirection = t.xDirection; + } + if (inType !== 'trackx') { + gestureProto.dy = d.y; + gestureProto.ddy = dd.y; + gestureProto.y = inEvent.y; + gestureProto.clientY = inEvent.clientY; + gestureProto.pageY = inEvent.pageY; + gestureProto.screenY = inEvent.screenY; + gestureProto.yDirection = t.yDirection; + } + var e = eventFactory.makeGestureEvent(inType, gestureProto); + t.downTarget.dispatchEvent(e); + }, + down: function(inEvent) { + if (inEvent.isPrimary && (inEvent.pointerType === 'mouse' ? inEvent.buttons === 1 : true)) { + var p = { + downEvent: inEvent, + downTarget: inEvent.target, + trackInfo: {}, + lastMoveEvent: null, + xDirection: 0, + yDirection: 0, + tracking: false + }; + pointermap.set(inEvent.pointerId, p); + } + }, + move: function(inEvent) { + var p = pointermap.get(inEvent.pointerId); + if (p) { + if (!p.tracking) { + var d = this.calcPositionDelta(p.downEvent, inEvent); + var move = d.x * d.x + d.y * d.y; + // start tracking only if finger moves more than WIGGLE_THRESHOLD + if (move > this.WIGGLE_THRESHOLD) { + p.tracking = true; + p.lastMoveEvent = p.downEvent; + this.fireTrack('trackstart', inEvent, p); + } + } + if (p.tracking) { + this.fireTrack('track', inEvent, p); + this.fireTrack('trackx', inEvent, p); + this.fireTrack('tracky', inEvent, p); + } + p.lastMoveEvent = inEvent; + } + }, + up: function(inEvent) { + var p = pointermap.get(inEvent.pointerId); + if (p) { + if (p.tracking) { + this.fireTrack('trackend', inEvent, p); + } + pointermap.delete(inEvent.pointerId); + } + } + }; + dispatcher.registerGesture('track', track); + })(window.PolymerGestures); + +/** + * This event is fired when a pointer is held down for 200ms. + * + * @module PointerGestures + * @submodule Events + * @class hold + */ +/** + * Type of pointer that made the holding event. + * @type String + * @property pointerType + */ +/** + * Screen X axis position of the held pointer + * @type Number + * @property clientX + */ +/** + * Screen Y axis position of the held pointer + * @type Number + * @property clientY + */ +/** + * Type of pointer that made the holding event. + * @type String + * @property pointerType + */ +/** + * This event is fired every 200ms while a pointer is held down. + * + * @class holdpulse + * @extends hold + */ +/** + * Milliseconds pointer has been held down. + * @type Number + * @property holdTime + */ +/** + * This event is fired when a held pointer is released or moved. + * + * @class release + */ + +(function(scope) { + var dispatcher = scope.dispatcher; + var eventFactory = scope.eventFactory; + var hold = { + // wait at least HOLD_DELAY ms between hold and pulse events + HOLD_DELAY: 200, + // pointer can move WIGGLE_THRESHOLD pixels before not counting as a hold + WIGGLE_THRESHOLD: 16, + events: [ + 'down', + 'move', + 'up', + ], + exposes: [ + 'hold', + 'holdpulse', + 'release' + ], + heldPointer: null, + holdJob: null, + pulse: function() { + var hold = Date.now() - this.heldPointer.timeStamp; + var type = this.held ? 'holdpulse' : 'hold'; + this.fireHold(type, hold); + this.held = true; + }, + cancel: function() { + clearInterval(this.holdJob); + if (this.held) { + this.fireHold('release'); + } + this.held = false; + this.heldPointer = null; + this.target = null; + this.holdJob = null; + }, + down: function(inEvent) { + if (inEvent.isPrimary && !this.heldPointer) { + this.heldPointer = inEvent; + this.target = inEvent.target; + this.holdJob = setInterval(this.pulse.bind(this), this.HOLD_DELAY); + } + }, + up: function(inEvent) { + if (this.heldPointer && this.heldPointer.pointerId === inEvent.pointerId) { + this.cancel(); + } + }, + move: function(inEvent) { + if (this.heldPointer && this.heldPointer.pointerId === inEvent.pointerId) { + var x = inEvent.clientX - this.heldPointer.clientX; + var y = inEvent.clientY - this.heldPointer.clientY; + if ((x * x + y * y) > this.WIGGLE_THRESHOLD) { + this.cancel(); + } + } + }, + fireHold: function(inType, inHoldTime) { + var p = { + bubbles: true, + cancelable: true, + pointerType: this.heldPointer.pointerType, + pointerId: this.heldPointer.pointerId, + x: this.heldPointer.clientX, + y: this.heldPointer.clientY, + _source: 'hold' + }; + if (inHoldTime) { + p.holdTime = inHoldTime; + } + var e = eventFactory.makeGestureEvent(inType, p); + this.target.dispatchEvent(e); + } + }; + dispatcher.registerGesture('hold', hold); +})(window.PolymerGestures); + +/** + * This event is fired when a pointer quickly goes down and up, and is used to + * denote activation. + * + * Any gesture event can prevent the tap event from being created by calling + * `event.preventTap`. + * + * Any pointer event can prevent the tap by setting the `tapPrevented` property + * on itself. + * + * @module PointerGestures + * @submodule Events + * @class tap + */ +/** + * X axis position of the tap. + * @property x + * @type Number + */ +/** + * Y axis position of the tap. + * @property y + * @type Number + */ +/** + * Type of the pointer that made the tap. + * @property pointerType + * @type String + */ +(function(scope) { + var dispatcher = scope.dispatcher; + var eventFactory = scope.eventFactory; + var pointermap = new scope.PointerMap(); + var tap = { + events: [ + 'down', + 'up' + ], + exposes: [ + 'tap' + ], + down: function(inEvent) { + if (inEvent.isPrimary && !inEvent.tapPrevented) { + pointermap.set(inEvent.pointerId, { + target: inEvent.target, + buttons: inEvent.buttons, + x: inEvent.clientX, + y: inEvent.clientY + }); + } + }, + shouldTap: function(e, downState) { + var tap = true; + if (e.pointerType === 'mouse') { + // only allow left click to tap for mouse + tap = (e.buttons ^ 1) && (downState.buttons & 1); + } + return tap && !e.tapPrevented; + }, + up: function(inEvent) { + var start = pointermap.get(inEvent.pointerId); + if (start && this.shouldTap(inEvent, start)) { + // up.relatedTarget is target currently under finger + var t = scope.targetFinding.LCA(start.target, inEvent.relatedTarget); + if (t) { + var e = eventFactory.makeGestureEvent('tap', { + bubbles: true, + cancelable: true, + x: inEvent.clientX, + y: inEvent.clientY, + detail: inEvent.detail, + pointerType: inEvent.pointerType, + pointerId: inEvent.pointerId, + altKey: inEvent.altKey, + ctrlKey: inEvent.ctrlKey, + metaKey: inEvent.metaKey, + shiftKey: inEvent.shiftKey, + _source: 'tap' + }); + t.dispatchEvent(e); + } + } + pointermap.delete(inEvent.pointerId); + } + }; + // patch eventFactory to remove id from tap's pointermap for preventTap calls + eventFactory.preventTap = function(e) { + return function() { + e.tapPrevented = true; + pointermap.delete(e.pointerId); + }; + }; + dispatcher.registerGesture('tap', tap); +})(window.PolymerGestures); + +/* + * Basic strategy: find the farthest apart points, use as diameter of circle + * react to size change and rotation of the chord + */ + +/** + * @module pointer-gestures + * @submodule Events + * @class pinch + */ +/** + * Scale of the pinch zoom gesture + * @property scale + * @type Number + */ +/** + * Center X position of pointers causing pinch + * @property centerX + * @type Number + */ +/** + * Center Y position of pointers causing pinch + * @property centerY + * @type Number + */ + +/** + * @module pointer-gestures + * @submodule Events + * @class rotate + */ +/** + * Angle (in degrees) of rotation. Measured from starting positions of pointers. + * @property angle + * @type Number + */ +/** + * Center X position of pointers causing rotation + * @property centerX + * @type Number + */ +/** + * Center Y position of pointers causing rotation + * @property centerY + * @type Number + */ +(function(scope) { + var dispatcher = scope.dispatcher; + var eventFactory = scope.eventFactory; + var pointermap = new scope.PointerMap(); + var RAD_TO_DEG = 180 / Math.PI; + var pinch = { + events: [ + 'down', + 'up', + 'move', + 'cancel' + ], + exposes: [ + 'pinch', + 'rotate' + ], + defaultActions: { + 'pinch': 'none', + 'rotate': 'none' + }, + reference: {}, + down: function(inEvent) { + pointermap.set(inEvent.pointerId, inEvent); + if (pointermap.pointers() == 2) { + var points = this.calcChord(); + var angle = this.calcAngle(points); + this.reference = { + angle: angle, + diameter: points.diameter, + target: scope.targetFinding.LCA(points.a.target, points.b.target) + }; + } + }, + up: function(inEvent) { + var p = pointermap.get(inEvent.pointerId); + if (p) { + pointermap.delete(inEvent.pointerId); + } + }, + move: function(inEvent) { + if (pointermap.has(inEvent.pointerId)) { + pointermap.set(inEvent.pointerId, inEvent); + if (pointermap.pointers() > 1) { + this.calcPinchRotate(); + } + } + }, + cancel: function(inEvent) { + this.up(inEvent); + }, + firePinch: function(diameter, points) { + var zoom = diameter / this.reference.diameter; + var e = eventFactory.makeGestureEvent('pinch', { + bubbles: true, + cancelable: true, + scale: zoom, + centerX: points.center.x, + centerY: points.center.y, + _source: 'pinch' + }); + this.reference.target.dispatchEvent(e); + }, + fireRotate: function(angle, points) { + var diff = Math.round((angle - this.reference.angle) % 360); + var e = eventFactory.makeGestureEvent('rotate', { + bubbles: true, + cancelable: true, + angle: diff, + centerX: points.center.x, + centerY: points.center.y, + _source: 'pinch' + }); + this.reference.target.dispatchEvent(e); + }, + calcPinchRotate: function() { + var points = this.calcChord(); + var diameter = points.diameter; + var angle = this.calcAngle(points); + if (diameter != this.reference.diameter) { + this.firePinch(diameter, points); + } + if (angle != this.reference.angle) { + this.fireRotate(angle, points); + } + }, + calcChord: function() { + var pointers = []; + pointermap.forEach(function(p) { + pointers.push(p); + }); + var dist = 0; + // start with at least two pointers + var points = {a: pointers[0], b: pointers[1]}; + var x, y, d; + for (var i = 0; i < pointers.length; i++) { + var a = pointers[i]; + for (var j = i + 1; j < pointers.length; j++) { + var b = pointers[j]; + x = Math.abs(a.clientX - b.clientX); + y = Math.abs(a.clientY - b.clientY); + d = x + y; + if (d > dist) { + dist = d; + points = {a: a, b: b}; + } + } + } + x = Math.abs(points.a.clientX + points.b.clientX) / 2; + y = Math.abs(points.a.clientY + points.b.clientY) / 2; + points.center = { x: x, y: y }; + points.diameter = dist; + return points; + }, + calcAngle: function(points) { + var x = points.a.clientX - points.b.clientX; + var y = points.a.clientY - points.b.clientY; + return (360 + Math.atan2(y, x) * RAD_TO_DEG) % 360; + } + }; + dispatcher.registerGesture('pinch', pinch); +})(window.PolymerGestures); + +(function (global) { + 'use strict'; + + var Token, + TokenName, + Syntax, + Messages, + source, + index, + length, + delegate, + lookahead, + state; + + Token = { + BooleanLiteral: 1, + EOF: 2, + Identifier: 3, + Keyword: 4, + NullLiteral: 5, + NumericLiteral: 6, + Punctuator: 7, + StringLiteral: 8 + }; + + TokenName = {}; + TokenName[Token.BooleanLiteral] = 'Boolean'; + TokenName[Token.EOF] = ''; + TokenName[Token.Identifier] = 'Identifier'; + TokenName[Token.Keyword] = 'Keyword'; + TokenName[Token.NullLiteral] = 'Null'; + TokenName[Token.NumericLiteral] = 'Numeric'; + TokenName[Token.Punctuator] = 'Punctuator'; + TokenName[Token.StringLiteral] = 'String'; + + Syntax = { + ArrayExpression: 'ArrayExpression', + BinaryExpression: 'BinaryExpression', + CallExpression: 'CallExpression', + ConditionalExpression: 'ConditionalExpression', + EmptyStatement: 'EmptyStatement', + ExpressionStatement: 'ExpressionStatement', + Identifier: 'Identifier', + Literal: 'Literal', + LabeledStatement: 'LabeledStatement', + LogicalExpression: 'LogicalExpression', + MemberExpression: 'MemberExpression', + ObjectExpression: 'ObjectExpression', + Program: 'Program', + Property: 'Property', + ThisExpression: 'ThisExpression', + UnaryExpression: 'UnaryExpression' + }; + + // Error messages should be identical to V8. + Messages = { + UnexpectedToken: 'Unexpected token %0', + UnknownLabel: 'Undefined label \'%0\'', + Redeclaration: '%0 \'%1\' has already been declared' + }; + + // Ensure the condition is true, otherwise throw an error. + // This is only to have a better contract semantic, i.e. another safety net + // to catch a logic error. The condition shall be fulfilled in normal case. + // Do NOT use this to enforce a certain condition on any user input. + + function assert(condition, message) { + if (!condition) { + throw new Error('ASSERT: ' + message); + } + } + + function isDecimalDigit(ch) { + return (ch >= 48 && ch <= 57); // 0..9 + } + + + // 7.2 White Space + + function isWhiteSpace(ch) { + return (ch === 32) || // space + (ch === 9) || // tab + (ch === 0xB) || + (ch === 0xC) || + (ch === 0xA0) || + (ch >= 0x1680 && '\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\uFEFF'.indexOf(String.fromCharCode(ch)) > 0); + } + + // 7.3 Line Terminators + + function isLineTerminator(ch) { + return (ch === 10) || (ch === 13) || (ch === 0x2028) || (ch === 0x2029); + } + + // 7.6 Identifier Names and Identifiers + + function isIdentifierStart(ch) { + return (ch === 36) || (ch === 95) || // $ (dollar) and _ (underscore) + (ch >= 65 && ch <= 90) || // A..Z + (ch >= 97 && ch <= 122); // a..z + } + + function isIdentifierPart(ch) { + return (ch === 36) || (ch === 95) || // $ (dollar) and _ (underscore) + (ch >= 65 && ch <= 90) || // A..Z + (ch >= 97 && ch <= 122) || // a..z + (ch >= 48 && ch <= 57); // 0..9 + } + + // 7.6.1.1 Keywords + + function isKeyword(id) { + return (id === 'this') + } + + // 7.4 Comments + + function skipWhitespace() { + while (index < length && isWhiteSpace(source.charCodeAt(index))) { + ++index; + } + } + + function getIdentifier() { + var start, ch; + + start = index++; + while (index < length) { + ch = source.charCodeAt(index); + if (isIdentifierPart(ch)) { + ++index; + } else { + break; + } + } + + return source.slice(start, index); + } + + function scanIdentifier() { + var start, id, type; + + start = index; + + id = getIdentifier(); + + // There is no keyword or literal with only one character. + // Thus, it must be an identifier. + if (id.length === 1) { + type = Token.Identifier; + } else if (isKeyword(id)) { + type = Token.Keyword; + } else if (id === 'null') { + type = Token.NullLiteral; + } else if (id === 'true' || id === 'false') { + type = Token.BooleanLiteral; + } else { + type = Token.Identifier; + } + + return { + type: type, + value: id, + range: [start, index] + }; + } + + + // 7.7 Punctuators + + function scanPunctuator() { + var start = index, + code = source.charCodeAt(index), + code2, + ch1 = source[index], + ch2; + + switch (code) { + + // Check for most common single-character punctuators. + case 46: // . dot + case 40: // ( open bracket + case 41: // ) close bracket + case 59: // ; semicolon + case 44: // , comma + case 123: // { open curly brace + case 125: // } close curly brace + case 91: // [ + case 93: // ] + case 58: // : + case 63: // ? + ++index; + return { + type: Token.Punctuator, + value: String.fromCharCode(code), + range: [start, index] + }; + + default: + code2 = source.charCodeAt(index + 1); + + // '=' (char #61) marks an assignment or comparison operator. + if (code2 === 61) { + switch (code) { + case 37: // % + case 38: // & + case 42: // *: + case 43: // + + case 45: // - + case 47: // / + case 60: // < + case 62: // > + case 124: // | + index += 2; + return { + type: Token.Punctuator, + value: String.fromCharCode(code) + String.fromCharCode(code2), + range: [start, index] + }; + + case 33: // ! + case 61: // = + index += 2; + + // !== and === + if (source.charCodeAt(index) === 61) { + ++index; + } + return { + type: Token.Punctuator, + value: source.slice(start, index), + range: [start, index] + }; + default: + break; + } + } + break; + } + + // Peek more characters. + + ch2 = source[index + 1]; + + // Other 2-character punctuators: && || + + if (ch1 === ch2 && ('&|'.indexOf(ch1) >= 0)) { + index += 2; + return { + type: Token.Punctuator, + value: ch1 + ch2, + range: [start, index] + }; + } + + if ('<>=!+-*%&|^/'.indexOf(ch1) >= 0) { + ++index; + return { + type: Token.Punctuator, + value: ch1, + range: [start, index] + }; + } + + throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); + } + + // 7.8.3 Numeric Literals + function scanNumericLiteral() { + var number, start, ch; + + ch = source[index]; + assert(isDecimalDigit(ch.charCodeAt(0)) || (ch === '.'), + 'Numeric literal must start with a decimal digit or a decimal point'); + + start = index; + number = ''; + if (ch !== '.') { + number = source[index++]; + ch = source[index]; + + // Hex number starts with '0x'. + // Octal number starts with '0'. + if (number === '0') { + // decimal number starts with '0' such as '09' is illegal. + if (ch && isDecimalDigit(ch.charCodeAt(0))) { + throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); + } + } + + while (isDecimalDigit(source.charCodeAt(index))) { + number += source[index++]; + } + ch = source[index]; + } + + if (ch === '.') { + number += source[index++]; + while (isDecimalDigit(source.charCodeAt(index))) { + number += source[index++]; + } + ch = source[index]; + } + + if (ch === 'e' || ch === 'E') { + number += source[index++]; + + ch = source[index]; + if (ch === '+' || ch === '-') { + number += source[index++]; + } + if (isDecimalDigit(source.charCodeAt(index))) { + while (isDecimalDigit(source.charCodeAt(index))) { + number += source[index++]; + } + } else { + throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); + } + } + + if (isIdentifierStart(source.charCodeAt(index))) { + throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); + } + + return { + type: Token.NumericLiteral, + value: parseFloat(number), + range: [start, index] + }; + } + + // 7.8.4 String Literals + + function scanStringLiteral() { + var str = '', quote, start, ch, octal = false; + + quote = source[index]; + assert((quote === '\'' || quote === '"'), + 'String literal must starts with a quote'); + + start = index; + ++index; + + while (index < length) { + ch = source[index++]; + + if (ch === quote) { + quote = ''; + break; + } else if (ch === '\\') { + ch = source[index++]; + if (!ch || !isLineTerminator(ch.charCodeAt(0))) { + switch (ch) { + case 'n': + str += '\n'; + break; + case 'r': + str += '\r'; + break; + case 't': + str += '\t'; + break; + case 'b': + str += '\b'; + break; + case 'f': + str += '\f'; + break; + case 'v': + str += '\x0B'; + break; + + default: + str += ch; + break; + } + } else { + if (ch === '\r' && source[index] === '\n') { + ++index; + } + } + } else if (isLineTerminator(ch.charCodeAt(0))) { + break; + } else { + str += ch; + } + } + + if (quote !== '') { + throwError({}, Messages.UnexpectedToken, 'ILLEGAL'); + } + + return { + type: Token.StringLiteral, + value: str, + octal: octal, + range: [start, index] + }; + } + + function isIdentifierName(token) { + return token.type === Token.Identifier || + token.type === Token.Keyword || + token.type === Token.BooleanLiteral || + token.type === Token.NullLiteral; + } + + function advance() { + var ch; + + skipWhitespace(); + + if (index >= length) { + return { + type: Token.EOF, + range: [index, index] + }; + } + + ch = source.charCodeAt(index); + + // Very common: ( and ) and ; + if (ch === 40 || ch === 41 || ch === 58) { + return scanPunctuator(); + } + + // String literal starts with single quote (#39) or double quote (#34). + if (ch === 39 || ch === 34) { + return scanStringLiteral(); + } + + if (isIdentifierStart(ch)) { + return scanIdentifier(); + } + + // Dot (.) char #46 can also start a floating-point number, hence the need + // to check the next character. + if (ch === 46) { + if (isDecimalDigit(source.charCodeAt(index + 1))) { + return scanNumericLiteral(); + } + return scanPunctuator(); + } + + if (isDecimalDigit(ch)) { + return scanNumericLiteral(); + } + + return scanPunctuator(); + } + + function lex() { + var token; + + token = lookahead; + index = token.range[1]; + + lookahead = advance(); + + index = token.range[1]; + + return token; + } + + function peek() { + var pos; + + pos = index; + lookahead = advance(); + index = pos; + } + + // Throw an exception + + function throwError(token, messageFormat) { + var error, + args = Array.prototype.slice.call(arguments, 2), + msg = messageFormat.replace( + /%(\d)/g, + function (whole, index) { + assert(index < args.length, 'Message reference must be in range'); + return args[index]; + } + ); + + error = new Error(msg); + error.index = index; + error.description = msg; + throw error; + } + + // Throw an exception because of the token. + + function throwUnexpected(token) { + throwError(token, Messages.UnexpectedToken, token.value); + } + + // Expect the next token to match the specified punctuator. + // If not, an exception will be thrown. + + function expect(value) { + var token = lex(); + if (token.type !== Token.Punctuator || token.value !== value) { + throwUnexpected(token); + } + } + + // Return true if the next token matches the specified punctuator. + + function match(value) { + return lookahead.type === Token.Punctuator && lookahead.value === value; + } + + // Return true if the next token matches the specified keyword + + function matchKeyword(keyword) { + return lookahead.type === Token.Keyword && lookahead.value === keyword; + } + + function consumeSemicolon() { + // Catch the very common case first: immediately a semicolon (char #59). + if (source.charCodeAt(index) === 59) { + lex(); + return; + } + + skipWhitespace(); + + if (match(';')) { + lex(); + return; + } + + if (lookahead.type !== Token.EOF && !match('}')) { + throwUnexpected(lookahead); + } + } + + // 11.1.4 Array Initialiser + + function parseArrayInitialiser() { + var elements = []; + + expect('['); + + while (!match(']')) { + if (match(',')) { + lex(); + elements.push(null); + } else { + elements.push(parseExpression()); + + if (!match(']')) { + expect(','); + } + } + } + + expect(']'); + + return delegate.createArrayExpression(elements); + } + + // 11.1.5 Object Initialiser + + function parseObjectPropertyKey() { + var token; + + skipWhitespace(); + token = lex(); + + // Note: This function is called only from parseObjectProperty(), where + // EOF and Punctuator tokens are already filtered out. + if (token.type === Token.StringLiteral || token.type === Token.NumericLiteral) { + return delegate.createLiteral(token); + } + + return delegate.createIdentifier(token.value); + } + + function parseObjectProperty() { + var token, key; + + token = lookahead; + skipWhitespace(); + + if (token.type === Token.EOF || token.type === Token.Punctuator) { + throwUnexpected(token); + } + + key = parseObjectPropertyKey(); + expect(':'); + return delegate.createProperty('init', key, parseExpression()); + } + + function parseObjectInitialiser() { + var properties = []; + + expect('{'); + + while (!match('}')) { + properties.push(parseObjectProperty()); + + if (!match('}')) { + expect(','); + } + } + + expect('}'); + + return delegate.createObjectExpression(properties); + } + + // 11.1.6 The Grouping Operator + + function parseGroupExpression() { + var expr; + + expect('('); + + expr = parseExpression(); + + expect(')'); + + return expr; + } + + + // 11.1 Primary Expressions + + function parsePrimaryExpression() { + var type, token, expr; + + if (match('(')) { + return parseGroupExpression(); + } + + type = lookahead.type; + + if (type === Token.Identifier) { + expr = delegate.createIdentifier(lex().value); + } else if (type === Token.StringLiteral || type === Token.NumericLiteral) { + expr = delegate.createLiteral(lex()); + } else if (type === Token.Keyword) { + if (matchKeyword('this')) { + lex(); + expr = delegate.createThisExpression(); + } + } else if (type === Token.BooleanLiteral) { + token = lex(); + token.value = (token.value === 'true'); + expr = delegate.createLiteral(token); + } else if (type === Token.NullLiteral) { + token = lex(); + token.value = null; + expr = delegate.createLiteral(token); + } else if (match('[')) { + expr = parseArrayInitialiser(); + } else if (match('{')) { + expr = parseObjectInitialiser(); + } + + if (expr) { + return expr; + } + + throwUnexpected(lex()); + } + + // 11.2 Left-Hand-Side Expressions + + function parseArguments() { + var args = []; + + expect('('); + + if (!match(')')) { + while (index < length) { + args.push(parseExpression()); + if (match(')')) { + break; + } + expect(','); + } + } + + expect(')'); + + return args; + } + + function parseNonComputedProperty() { + var token; + + token = lex(); + + if (!isIdentifierName(token)) { + throwUnexpected(token); + } + + return delegate.createIdentifier(token.value); + } + + function parseNonComputedMember() { + expect('.'); + + return parseNonComputedProperty(); + } + + function parseComputedMember() { + var expr; + + expect('['); + + expr = parseExpression(); + + expect(']'); + + return expr; + } + + function parseLeftHandSideExpression() { + var expr, args, property; + + expr = parsePrimaryExpression(); + + while (true) { + if (match('[')) { + property = parseComputedMember(); + expr = delegate.createMemberExpression('[', expr, property); + } else if (match('.')) { + property = parseNonComputedMember(); + expr = delegate.createMemberExpression('.', expr, property); + } else if (match('(')) { + args = parseArguments(); + expr = delegate.createCallExpression(expr, args); + } else { + break; + } + } + + return expr; + } + + // 11.3 Postfix Expressions + + var parsePostfixExpression = parseLeftHandSideExpression; + + // 11.4 Unary Operators + + function parseUnaryExpression() { + var token, expr; + + if (lookahead.type !== Token.Punctuator && lookahead.type !== Token.Keyword) { + expr = parsePostfixExpression(); + } else if (match('+') || match('-') || match('!')) { + token = lex(); + expr = parseUnaryExpression(); + expr = delegate.createUnaryExpression(token.value, expr); + } else if (matchKeyword('delete') || matchKeyword('void') || matchKeyword('typeof')) { + throwError({}, Messages.UnexpectedToken); + } else { + expr = parsePostfixExpression(); + } + + return expr; + } + + function binaryPrecedence(token) { + var prec = 0; + + if (token.type !== Token.Punctuator && token.type !== Token.Keyword) { + return 0; + } + + switch (token.value) { + case '||': + prec = 1; + break; + + case '&&': + prec = 2; + break; + + case '==': + case '!=': + case '===': + case '!==': + prec = 6; + break; + + case '<': + case '>': + case '<=': + case '>=': + case 'instanceof': + prec = 7; + break; + + case 'in': + prec = 7; + break; + + case '+': + case '-': + prec = 9; + break; + + case '*': + case '/': + case '%': + prec = 11; + break; + + default: + break; + } + + return prec; + } + + // 11.5 Multiplicative Operators + // 11.6 Additive Operators + // 11.7 Bitwise Shift Operators + // 11.8 Relational Operators + // 11.9 Equality Operators + // 11.10 Binary Bitwise Operators + // 11.11 Binary Logical Operators + + function parseBinaryExpression() { + var expr, token, prec, stack, right, operator, left, i; + + left = parseUnaryExpression(); + + token = lookahead; + prec = binaryPrecedence(token); + if (prec === 0) { + return left; + } + token.prec = prec; + lex(); + + right = parseUnaryExpression(); + + stack = [left, token, right]; + + while ((prec = binaryPrecedence(lookahead)) > 0) { + + // Reduce: make a binary expression from the three topmost entries. + while ((stack.length > 2) && (prec <= stack[stack.length - 2].prec)) { + right = stack.pop(); + operator = stack.pop().value; + left = stack.pop(); + expr = delegate.createBinaryExpression(operator, left, right); + stack.push(expr); + } + + // Shift. + token = lex(); + token.prec = prec; + stack.push(token); + expr = parseUnaryExpression(); + stack.push(expr); + } + + // Final reduce to clean-up the stack. + i = stack.length - 1; + expr = stack[i]; + while (i > 1) { + expr = delegate.createBinaryExpression(stack[i - 1].value, stack[i - 2], expr); + i -= 2; + } + + return expr; + } + + + // 11.12 Conditional Operator + + function parseConditionalExpression() { + var expr, consequent, alternate; + + expr = parseBinaryExpression(); + + if (match('?')) { + lex(); + consequent = parseConditionalExpression(); + expect(':'); + alternate = parseConditionalExpression(); + + expr = delegate.createConditionalExpression(expr, consequent, alternate); + } + + return expr; + } + + // Simplification since we do not support AssignmentExpression. + var parseExpression = parseConditionalExpression; + + // Polymer Syntax extensions + + // Filter :: + // Identifier + // Identifier "(" ")" + // Identifier "(" FilterArguments ")" + + function parseFilter() { + var identifier, args; + + identifier = lex(); + + if (identifier.type !== Token.Identifier) { + throwUnexpected(identifier); + } + + args = match('(') ? parseArguments() : []; + + return delegate.createFilter(identifier.value, args); + } + + // Filters :: + // "|" Filter + // Filters "|" Filter + + function parseFilters() { + while (match('|')) { + lex(); + parseFilter(); + } + } + + // TopLevel :: + // LabelledExpressions + // AsExpression + // InExpression + // FilterExpression + + // AsExpression :: + // FilterExpression as Identifier + + // InExpression :: + // Identifier, Identifier in FilterExpression + // Identifier in FilterExpression + + // FilterExpression :: + // Expression + // Expression Filters + + function parseTopLevel() { + skipWhitespace(); + peek(); + + var expr = parseExpression(); + if (expr) { + if (lookahead.value === ',' || lookahead.value == 'in' && + expr.type === Syntax.Identifier) { + parseInExpression(expr); + } else { + parseFilters(); + if (lookahead.value === 'as') { + parseAsExpression(expr); + } else { + delegate.createTopLevel(expr); + } + } + } + + if (lookahead.type !== Token.EOF) { + throwUnexpected(lookahead); + } + } + + function parseAsExpression(expr) { + lex(); // as + var identifier = lex().value; + delegate.createAsExpression(expr, identifier); + } + + function parseInExpression(identifier) { + var indexName; + if (lookahead.value === ',') { + lex(); + if (lookahead.type !== Token.Identifier) + throwUnexpected(lookahead); + indexName = lex().value; + } + + lex(); // in + var expr = parseExpression(); + parseFilters(); + delegate.createInExpression(identifier.name, indexName, expr); + } + + function parse(code, inDelegate) { + delegate = inDelegate; + source = code; + index = 0; + length = source.length; + lookahead = null; + state = { + labelSet: {} + }; + + return parseTopLevel(); + } + + global.esprima = { + parse: parse + }; +})(this); + +// Copyright (c) 2014 The Polymer Project Authors. All rights reserved. +// This code may only be used under the BSD style license found at http://polymer.github.io/LICENSE.txt +// The complete set of authors may be found at http://polymer.github.io/AUTHORS.txt +// The complete set of contributors may be found at http://polymer.github.io/CONTRIBUTORS.txt +// Code distributed by Google as part of the polymer project is also +// subject to an additional IP rights grant found at http://polymer.github.io/PATENTS.txt + +(function (global) { + 'use strict'; + + function prepareBinding(expressionText, name, node, filterRegistry) { + var expression; + try { + expression = getExpression(expressionText); + if (expression.scopeIdent && + (node.nodeType !== Node.ELEMENT_NODE || + node.tagName !== 'TEMPLATE' || + (name !== 'bind' && name !== 'repeat'))) { + throw Error('as and in can only be used within