rijs/client/ripple.bundle.js

On the server:

var rijs = (function () {
	'use strict';

	function commonjsRequire () {
		throw new Error('Dynamic requires are not currently supported by rollup-plugin-commonjs');
	}

	function createCommonjsModule(fn, module) {
		return module = { exports: {} }, fn(module, module.exports), module.exports;
	}

	var client = typeof window != 'undefined';

	var promise_1 = promise;

	function promise() {
	  var resolve
	    , reject
	    , p = new Promise(function(res, rej){ 
	        resolve = res, reject = rej;
	      });

	  arguments.length && resolve(arguments[0]);
	  p.resolve = resolve;
	  p.reject  = reject;
	  return p
	}

	var flatten = function flatten(p,v){ 
	  if (v instanceof Array) { v = v.reduce(flatten, []); }
	  return p = p || [], p.concat(v) 
	};

	var has = function has(o, k) {
	  return k in o
	};

	var def = function def(o, p, v, w){
	  if (o.host && o.host.nodeName) { o = o.host; }
	  if (p.name) { v = p, p = p.name; }
	  !has(o, p) && Object.defineProperty(o, p, { value: v, writable: w });
	  return o[p]
	};

	var noop = function(){};

	var emitterify = function emitterify(body, hooks) {
	  body = body || {};
	  hooks = hooks || {};
	  def(body, 'emit', emit, 1);
	  def(body, 'once', once, 1);
	  def(body, 'off', off, 1);
	  def(body, 'on', on, 1);
	  body.on['*'] = body.on['*'] || [];
	  return body

	  function emit(type, pm, filter) {
	    var li = body.on[type.split('.')[0]] || []
	      , results = [];

	    for (var i = 0; i < li.length; i++)
	      { if (!li[i].ns || !filter || filter(li[i].ns))
	        { results.push(call(li[i].isOnce ? li.splice(i--, 1)[0] : li[i], pm)); } }

	    for (var i = 0; i < body.on['*'].length; i++)
	      { results.push(call(body.on['*'][i], [type, pm])); }

	    return results.reduce(flatten, [])
	  }

	  function call(cb, pm){
	    return cb.next             ? cb.next(pm) 
	         : pm instanceof Array ? cb.apply(body, pm) 
	                               : cb.call(body, pm) 
	  }

	  function on(type, opts, isOnce) {
	    var id = type.split('.')[0]
	      , ns = type.split('.')[1]
	      , li = body.on[id] = body.on[id] || []
	      , cb = typeof opts == 'function' ? opts : 0;

	    return !cb &&  ns ? (cb = body.on[id]['$'+ns]) ? cb : push(observable(body, opts))
	         : !cb && !ns ? push(observable(body, opts))
	         :  cb &&  ns ? push((remove(li, body.on[id]['$'+ns] || -1), cb))
	         :  cb && !ns ? push(cb)
	                      : false

	    function push(cb){
	      cb.isOnce = isOnce;
	      cb.type = id;
	      if (ns) { body.on[id]['$'+(cb.ns = ns)] = cb; }
	      li.push(cb)
	      ;(hooks.on || noop)(cb);
	      return cb.next ? cb : body
	    }
	  }

	  function once(type, callback){
	    return body.on(type, callback, true)
	  }

	  function remove(li, cb) {
	    var i = li.length;
	    while (~--i) 
	      { if (cb == li[i] || cb == li[i].fn || !cb)
	        { (hooks.off || noop)(li.splice(i, 1)[0]); } }
	  }

	  function off(type, cb) {
	    remove((body.on[type] || []), cb);
	    if (cb && cb.ns) { delete body.on[type]['$'+cb.ns]; }
	    return body
	  }

	  function observable(parent, opts) {
	    opts = opts || {};
	    var o = emitterify(opts.base || promise_1());
	    o.i = 0;
	    o.li = [];
	    o.fn = opts.fn;
	    o.parent = parent;
	    o.source = opts.fn ? o.parent.source : o;
	    
	    o.on('stop', function(reason){
	      o.type
	        ? o.parent.off(o.type, o)
	        : o.parent.off(o);
	      return o.reason = reason
	    });

	    o.each = function(fn) {
	      var n = fn.next ? fn : observable(o, { fn: fn });
	      o.li.push(n);
	      return n
	    };

	    o.pipe = function(fn) {
	      return fn(o)
	    };

	    o.map = function(fn){
	      return o.each(function(d, i, n){ return n.next(fn(d, i, n)) })
	    };

	    o.filter = function(fn){
	      return o.each(function(d, i, n){ return fn(d, i, n) && n.next(d) })
	    };

	    o.reduce = function(fn, acc) {
	      return o.each(function(d, i, n){ return n.next(acc = fn(acc, d, i, n)) })
	    };

	    o.unpromise = function(){ 
	      var n = observable(o, { base: {}, fn: function(d){ return n.next(d) } });
	      o.li.push(n);
	      return n
	    };

	    o.next = function(value) {
	      o.resolve && o.resolve(value);
	      return o.li.length 
	           ? o.li.map(function(n){ return n.fn(value, n.i++, n) })
	           : value
	    };

	    o.until = function(stop){
	      (stop.each || stop.then).call(stop, function(reason){ return o.source.emit('stop', reason) });
	      return o
	    };

	    o.off = function(fn){
	      return remove(o.li, fn), o
	    };

	    o.start = function(fn){
	      o.source.emit('start');
	      return o
	    };

	    o[Symbol.asyncIterator] = function(){ 
	      return { 
	        next: function(){ 
	          return o.wait = new Promise(function(resolve){
	            o.wait = true;
	            o.map(function(d, i, n){
	              delete o.wait;
	              o.off(n);
	              resolve({ value: d, done: false });
	            });
	            o.emit('pull', o);
	          })
	        }
	      }
	    };

	    return o
	  }
	};

	var is_1 = is;
	is.fn      = isFunction;
	is.str     = isString;
	is.num     = isNumber;
	is.obj     = isObject;
	is.lit     = isLiteral;
	is.bol     = isBoolean;
	is.truthy  = isTruthy;
	is.falsy   = isFalsy;
	is.arr     = isArray;
	is.null    = isNull;
	is.def     = isDef;
	is.in      = isIn;
	is.promise = isPromise;
	is.stream  = isStream;

	function is(v){
	  return function(d){
	    return d == v
	  }
	}

	function isFunction(d) {
	  return typeof d == 'function'
	}

	function isBoolean(d) {
	  return typeof d == 'boolean'
	}

	function isString(d) {
	  return typeof d == 'string'
	}

	function isNumber(d) {
	  return typeof d == 'number'
	}

	function isObject(d) {
	  return typeof d == 'object'
	}

	function isLiteral(d) {
	  return d.constructor == Object
	}

	function isTruthy(d) {
	  return !!d == true
	}

	function isFalsy(d) {
	  return !!d == false
	}

	function isArray(d) {
	  return d instanceof Array
	}

	function isNull(d) {
	  return d === null
	}

	function isDef(d) {
	  return typeof d !== 'undefined'
	}

	function isPromise(d) {
	  return d instanceof Promise
	}

	function isStream(d) {
	  return !!(d && d.next)
	}

	function isIn(set) {
	  return function(d){
	    return !set ? false  
	         : set.indexOf ? ~set.indexOf(d)
	         : d in set
	  }
	}

	var colorfill_1 = colorfill();

	function colorfill(){
	  /* istanbul ignore next */
	  ['red', 'green', 'bold', 'grey', 'strip'].forEach(function(color) {
	    !is_1.str(String.prototype[color]) && Object.defineProperty(String.prototype, color, {
	      get: function() {
	        return String(this)
	      } 
	    });
	  });
	}

	var identity = function identity(d) {
	  return d
	};

	var wrap = function wrap(d){
	  return function(){
	    return d
	  }
	};

	var keys = function keys(o) { 
	  return Object.keys(is_1.obj(o) || is_1.fn(o) ? o : {})
	};

	var str = function str(d){
	  return d === 0 ? '0'
	       : !d ? ''
	       : is_1.fn(d) ? '' + d
	       : is_1.obj(d) ? JSON.stringify(d)
	       : String(d)
	};

	var key = function key(k, v){ 
	  var set = arguments.length > 1
	    , keys$$1 = is_1.fn(k) ? [] : str(k).split('.').filter(Boolean)
	    , root = keys$$1.shift();

	  return function deep(o, i){
	    var masked = {};
	    
	    return !o ? undefined 
	         : !is_1.num(k) && !k ? (set ? replace(o, v) : o)
	         : is_1.arr(k) ? (k.map(copy), masked)
	         : o[k] || !keys$$1.length ? (set ? (o[k] = is_1.fn(v) ? v(o[k], i) : v, o)
	                                       :  (is_1.fn(k) ? k(o) : o[k]))
	                                : (set ? (key(keys$$1.join('.'), v)(o[root] ? o[root] : (o[root] = {})), o)
	                                       :  key(keys$$1.join('.'))(o[root]))

	    function copy(k){
	      var val = key(k)(o);
	      val = is_1.fn(v)       ? v(val) 
	          : val == undefined ? v
	                           : val;
	    if (val != undefined) 
	        { key(k, is_1.fn(val) ? wrap(val) : val)(masked); }
	    }

	    function replace(o, v) {
	      keys(o).map(function(k){ delete o[k]; });
	      keys(v).map(function(k){ o[k] = v[k]; });
	      return o
	    }
	  }
	};

	var header = function header(header$1, value) {
	  var getter = arguments.length == 1;
	  return function(d){ 
	    return !d || !d.headers ? null
	         : getter ? key(header$1)(d.headers)
	                  : key(header$1)(d.headers) == value
	  }
	};

	var datum = function datum(node){
	  return node.__data__
	};

	var from_1 = from;
	from.parent = fromParent;

	function from(o){
	  return function(k){
	    return key(k)(o)
	  }
	}

	function fromParent(k){
	  return datum(this.parentNode)[k]
	}

	var values = function values(o) {
	  return !o ? [] : keys(o).map(from_1(o))
	};

	var to = { 
	  arr: toArray
	, obj: toObject
	};

	function toArray(d){
	  return Array.prototype.slice.call(d, 0)
	}

	function toObject(d) {
	  var by = 'id'
	    ;

	  return arguments.length == 1 
	    ? (by = d, reduce)
	    : reduce.apply(this, arguments)

	  function reduce(p,v,i){
	    if (i === 0) { p = {}; }
	    p[is_1.fn(by) ? by(v, i) : v[by]] = v;
	    return p
	  }
	}

	var za = function az() {
	  return compare(to.arr(arguments))
	};

	function compare(keys){ 
	  return function(a, b){
	    if (!keys.length) { return 0 }
	    var k = keys[0]
	      , ka = key(k)(a) || ''
	      , kb = key(k)(b) || '';

	    return ka < kb ?  1 
	         : ka > kb ? -1 
	         : compare(keys.slice(1))(a, b)
	  }
	}

	var includes = function includes(pattern){
	  return function(d){
	    return d && d.indexOf && ~d.indexOf(pattern)
	  }
	};

	var text = {
	  header: 'text/plain'
	, check: function check(res){ return !includes('.html')(res.name) && !includes('.css')(res.name) && is_1.str(res.body) }
	};

	var owner = client ? /* istanbul ignore next */ window : global;

	var err = function err(ns){
	  return function(d){
	    if (!owner.console || !console.error.apply) { return d; }
	    is_1.arr(arguments[2]) && (arguments[2] = arguments[2].length);
	    var args = to.arr(arguments)
	      , prefix = '[err][' + (new Date()).toISOString() + ']' + ns;

	    args.unshift(prefix.red ? prefix.red : prefix);
	    return console.error.apply(console, args), d
	  }
	};

	var log = function log(ns){
	  return function(d){
	    if (!owner.console || !console.log.apply) { return d; }
	    is_1.arr(arguments[2]) && (arguments[2] = arguments[2].length);
	    var args = to.arr(arguments)
	      , prefix = '[log][' + (new Date()).toISOString() + ']' + ns;

	    args.unshift(prefix.grey ? prefix.grey : prefix);
	    return console.log.apply(console, args), d
	  }
	};

	// -------------------------------------------
	// API: Gets or sets a resource
	// -------------------------------------------
	// ripple('name')     - returns the resource body if it exists
	// ripple('name')     - creates & returns resource if it doesn't exist
	// ripple('name', {}) - creates & returns resource, with specified name and body
	// ripple({ ... })    - creates & returns resource, with specified name, body and headers
	// ripple.resources   - returns raw resources
	// ripple.register    - alias for ripple
	// ripple.on          - event listener for changes - all resources
	// ripple('name').on  - event listener for changes - resource-specific

	var rijs_core = function core(ref){
	  if ( ref === void 0 ) ref = {};
	  var aliases = ref.aliases; if ( aliases === void 0 ) aliases = {};

	  log$1('creating');

	  ripple.resources = {};
	  ripple.link      = link(ripple);
	  ripple.register  = ripple;
	  ripple.types     = types();
	  return linkify(emitterify(ripple), aliases)

	  function ripple(name, body, headers){
	    return !name                                            ? ripple
	         : is_1.arr(name)                                     ? name.map(ripple)
	         : is_1.promise(name)                                 ? name.then(ripple).catch(err$1)
	         : is_1.obj(name) && !name.name                       ? ripple(values(name))
	         : is_1.fn(name)  &&  name.resources                  ? ripple(values(name.resources))
	         : is_1.str(name) && !body &&  ripple.resources[name] ? ripple.resources[name].body
	         : is_1.str(name) && !body && !ripple.resources[name] ? undefined
	         : is_1.str(name) &&  body                            ? register(ripple)({ name: name, body: body, headers: headers })
	         : is_1.obj(name)                                     ? register(ripple)(name)
	         : (err$1('could not find or create resource', name), false)
	  }
	};

	var register = function (ripple) { return function (ref) {
	  var name = ref.name;
	  var body = ref.body;
	  var headers = ref.headers; if ( headers === void 0 ) headers = {};

	  name = ripple.aliases.src[name] || name;
	  if (is_1.promise(body)) { return body.then(function (body) { return register(ripple)({ name: name, body: body, headers: headers }); }).catch(err$1) }
	  log$1('registering', name);
	  var res = normalise(ripple)({ name: name, body: body, headers: headers });

	  if (!res) { return err$1('failed to register', name), false }
	  ripple.resources[name] = res;
	  ripple.emit('change', [name, { 
	    type: 'update'
	  , value: res.body
	  , time: now(res)
	  }]);

	  return ripple.resources[name].body
	}; };

	var normalise = function (ripple) { return function (res) {
	  if (!header('content-type')(res)) { values(ripple.types).sort(za('priority')).some(contentType(res)); }
	  if (!header('content-type')(res)) { return err$1('could not understand resource', res), false }
	  return parse(ripple)(res)
	}; };

	var parse = function (ripple) { return function (res) {
	  var type = header('content-type')(res);
	  if (!ripple.types[type]) { return err$1('could not understand type', type), false }
	  return (ripple.types[type].parse || identity)(res)
	}; };

	var contentType = function (res) { return function (type) { return type.check(res) && (res.headers['content-type'] = type.header); }; };

	var types = function () { return [text].reduce(to.obj('header'), 1); };

	var linkify = function (ripple, aliases) {
	  ripple.aliases = { dst: {}, src: {} };
	  for (var name in aliases)
	    { ripple.link(aliases[name], name); }
	  return ripple
	};

	var link = function (ripple) { return function (from, to$$1) {
	  ripple.aliases.src[from] = to$$1;
	  ripple.aliases.dst[to$$1] = from;
	  Object.defineProperty(ripple.resources, from, { 
	    get: function get(){ return ripple.resources[to$$1] } 
	  , set: function set(value){ ripple.resources[to$$1] = value; } 
	  });
	}; };

	var err$1 = err('[ri/core]')
	    , log$1 = log('[ri/core]')
	    , now = function (d, t) { return (t = key('body.log.length')(d), is_1.num(t) ? t - 1 : t); };

	// -------------------------------------------
	// Exposes a convenient global instance 
	// -------------------------------------------
	var rijs_singleton = function singleton(ripple){
	  log$2('creating');
	  if (!owner.ripple) { owner.ripple = ripple; }
	  return ripple
	};

	var log$2 = log('[ri/singleton]');

	var copy = function copy(from, to){ 
	  return function(d){ 
	    return to[d] = from[d], d
	  }
	};

	var overwrite = function overwrite(to){ 
	  return function(from){
	    keys(from)
	      .map(copy(from, to));
	        
	    return to
	  }
	};

	var not = function not(fn){
	  return function(){
	    return !fn.apply(this, arguments)
	  }
	};

	var extend = function extend(to){ 
	  return function(from){
	    keys(from)
	      .filter(not(is_1.in(to)))
	      .map(copy(from, to));

	    return to
	  }
	};

	var merge_1 = merge;

	function merge(to){ 
	  return function(from){
	    for (x in from) 
	      { is_1.obj(from[x]) && is_1.obj(to[x])
	        ? merge(to[x])(from[x])
	        : (to[x] = from[x]); }
	    return to
	  }
	}

	var attr = function attr(name, value) {
	  var args = arguments.length;
	  
	  return !is_1.str(name) && args == 2 ? attr(arguments[1]).call(this, arguments[0])
	       : !is_1.str(name) && args == 3 ? attr(arguments[1], arguments[2]).call(this, arguments[0])
	       :  function(el){
	            var ctx = this || {};
	            el = ctx.nodeName || is_1.fn(ctx.node) ? ctx : el;
	            el = el.node ? el.node() : el;
	            el = el.host || el;

	            return args > 1 && value === false ? el.removeAttribute(name)
	                 : args > 1                    ? (el.setAttribute(name, value), value)
	                 : el.attributes.getNamedItem(name) 
	                && el.attributes.getNamedItem(name).value
	          } 
	};

	var act = { add: add, update: update, remove: remove }
	  , str$1 = JSON.stringify
	  , parse$1 = JSON.parse;

	var set = function set(d, skipEmit) {
	  return function(o, existing, max) {
	    if (!is_1.obj(o) && !is_1.fn(o))
	      { return o }

	    if (!is_1.obj(d)) { 
	      var log = existing || o.log || []
	        , root = o;

	      if (!is_1.def(max)) { max = log.max || 0; }
	      if (!max)    { log = []; }
	      if (max < 0) { log = log.concat(null); }
	      if (max > 0) {
	        var s = str$1(o);
	        root = parse$1(s); 
	        log = log.concat({ type: 'update', value: parse$1(s), time: log.length });
	      } 

	      def(log, 'max', max);
	      
	      root.log 
	        ? (root.log = log)
	        : def(emitterify(root, null), 'log', log, 1);

	      return root
	    }

	    if (is_1.def(d.key)) {
	      if (!apply(o, d.type, (d.key = '' + d.key).split('.').filter(Boolean), d.value))
	        { return false }
	    } else
	      { return false }

	    if (o.log && o.log.max) 
	      { o.log.push((d.time = o.log.length, o.log.max > 0 ? d : null)); }

	    if (!skipEmit && o.emit)
	      { o.emit('change', d); }

	    return o
	  }
	};

	function apply(body, type, path, value) {
	  var next = path.shift();

	  if (!act[type]) 
	    { return false }
	  if (path.length) { 
	    if (!(next in body)) 
	      { if (type == 'remove') { return true }
	      else { body[next] = {}; } }
	    return apply(body[next], type, path, value)
	  }
	  else {
	    return !act[type](body, next, value)
	  }
	}

	function add(o, k, v) {
	  is_1.arr(o) 
	    ? o.splice(k, 0, v) 
	    : (o[k] = v);
	}

	function update(o, k, v) {
	  if (!is_1.num(k) && !k) {
	    if (!is_1.obj(v)) { return true }
	    for (var x in o) { delete o[x]; }
	    for (var x in v) { o[x] = v[x]; }
	  } else 
	    { o[k] = v; } 
	}

	function remove(o, k, v) { 
	  is_1.arr(o) 
	    ? o.splice(k, 1)
	    : delete o[k];
	}

	// -------------------------------------------
	// Adds support for data resources
	// -------------------------------------------
	var rijs_data = function data(ripple){
	  log$3('creating');
	  ripple
	    .on('change.data')
	    .filter(function (ref) {
	      var name = ref[0];
	      var change = ref[1];

	      return header('content-type', 'application/data')(ripple.resources[name]);
	  })
	    .filter(function (ref) {
	      var name = ref[0];
	      var change = ref[1];

	      return change && change.key;
	  })
	    .map(function (ref) {
	      var name = ref[0];
	      var change = ref[1];

	      return ripple
	      .resources[name]
	      .body
	      .emit('change', (change || null), not(is_1.in(['bubble'])));
	  });

	  ripple.types['application/data'] = {
	    header: 'application/data'
	  , ext: '*.data.js'
	  , selector: function (res) { return ("[data~=\"" + (res.name) + "\"]"); }
	  , extract: function (el) { return (attr("data")(el) || '').split(' '); }
	  , check: function (res) { return is_1.obj(res.body); }
	  , load: function load(res) {
	      var exported = commonjsRequire(res.headers.path);
	      exported = exported.default || exported;
	      exported = is_1.fn(exported) ? exported(ripple) : exported;
	      res.headers['content-type'] = this.header;
	      ripple(merge_1(res)(exported));
	      return ripple.resources[res.name]
	    }
	  , parse: function parse(res){ 
	      var existing = ripple.resources[res.name] || {};

	      extend(res.headers)(existing.headers);
	      res.body = set()(
	        res.body || []
	      , existing.body && existing.body.log
	      , is_1.num(res.headers.log) ? res.headers.log : -1
	      );
	      overwrite(res.body.on)(listeners(existing));
	      res.body.on('change.bubble', function (change) {
	        ripple.emit('change', ripple.change = [res.name, change], not(is_1.in(['data'])));
	        delete ripple.change;
	      });

	      if (res.headers.loaded && !res.headers.loading)
	        { res.headers.loading = Promise.resolve(res.headers.loaded(ripple, res))
	          .then(function () { 
	            delete res.headers.loading;
	            return res
	          }); }

	      return res
	    }
	  };

	  return ripple
	};

	var log$3 = log('[ri/types/data]')
	    , listeners = key('body.on');

	var djbx = function (str) {
	  var hash = 5381
	    , i = str.length;

	  while (i)
	    { hash = (hash * 33) ^ str.charCodeAt(--i); }

	  return hash >>> 0
	};

	var client_1 = function(ripple) {
	    return log$4("creating"), ripple.types["text/css"] = {
	        header: "text/css",
	        ext: "*.css",
	        selector: function (res) { return ("[css~=\"" + (res.name) + "\"]"); },
	        extract: function (el) { return (attr("css")(el) || "").split(" "); },
	        check: function (res) { return includes(".css")(res.name); },
	        shortname: function (path) { return basename(path); },
	        load: !1,
	        parse: function (res) { return (res.headers.hash = res.headers.hash || djbx(res.body), res); }
	    }, ripple;
	};

	var log$4 = log("[ri/types/css]");

	var basename;

	var lo = function lo(d){
	  return (d || '').toLowerCase()
	};

	var client_1$1 = function(ripple, ref) {
	    if ( ref === void 0 ) ref = {};
	    var dir = ref.dir; if ( dir === void 0 ) dir = ".";

	    return log$5("creating"), ripple.require = (function (res) { return function (module) {
	        if (module in res.headers.dependencies && ripple.resources[res.headers.dependencies[module]]) { return ripple(res.headers.dependencies[module]); }
	        throw new Error(("Cannot find module: " + module + " for " + (res.name)));
	    }; }), ripple.types["application/javascript"] = {
	        header: header$1,
	        selector: function (res) { return ((res.name) + ",[is~=\"" + (res.name) + "\"]"); },
	        extract: function (el) { return (attr("is")(el) || "").split(" ").concat(lo(el.nodeName)); },
	        ext: "*.js",
	        shortname: function (path) { return basename$1(path).split(".").slice(0, -1).join("."); },
	        check: function (res) { return is_1.fn(res.body); },
	        load: !1,
	        parse: function (res) {
	            if ("cjs" == res.headers.format) {
	                var m = {
	                    exports: {}
	                };
	                res.body(m, m.exports, ripple.require(res), {
	                    env: {}
	                }), res.body = m.exports;
	            }
	            return res;
	        }
	    }, ripple;
	};

	var log$5 = log("[ri/types/fn]"), header$1 = "application/javascript";

	var basename$1;

	var nanosocket = function(url){
	  if ( url === void 0 ) url = location.href.replace('http', 'ws');

	  var io = emitterify({ attempt: 0 });
	  io.ready = io.once('connected');
	  io.connect = connect(io, url);
	  io.connect(); 
	  io.send = function (data) { return io.ready.then(function (socket) { return socket.send(data); }); };
	  return io
	};

	var min = Math.min;
	var pow = Math.pow;

	var connect = function (io, url) { return function () {
	  var WebSocket = window.WebSocket;
	  var location = window.location;
	  var setTimeout = window.setTimeout;
	  var socket = new WebSocket(url);
	  socket.onopen = function (d) { return io.emit('connected', socket); };
	  socket.onmessage = function (d) { return io.emit('recv', d.data); };
	  socket.onclose = function (d) { 
	    io.ready = io.once('connected');
	    io.emit('disconnected');
	    setTimeout(io.connect, backoff(++io.attempt));
	  };
	}; };

	var backoff = function (attempt, base, cap) {
	    if ( base === void 0 ) base = 100;
	    if ( cap === void 0 ) cap = 10000;

	    return min(cap, base * pow(2, attempt));
	};

	var cryo = createCommonjsModule(function (module) {
	(function() {

	  var CONTAINER_TYPES = 'object array date function'.split(' ');

	  var REFERENCE_FLAG = '_CRYO_REF_';
	  var INFINITY_FLAG = '_CRYO_INFINITY_';
	  var FUNCTION_FLAG = '_CRYO_FUNCTION_';
	  var UNDEFINED_FLAG = '_CRYO_UNDEFINED_';
	  var DATE_FLAG = '_CRYO_DATE_';

	  var OBJECT_FLAG = '_CRYO_OBJECT_';
	  var ARRAY_FLAG = '_CRYO_ARRAY_';

	  function typeOf(item) {
	    if (typeof item === 'object') {
	      if (item === null) { return 'null'; }
	      if (item && item.nodeType === 1) { return 'dom'; }
	      if (item instanceof Array) { return 'array'; }
	      if (item instanceof Date) { return 'date'; }
	      return 'object';
	    }
	    return typeof item;
	  }

	  // Same as and copied from _.defaults
	  function defaults(obj) {
	    var arguments$1 = arguments;

	    var length = arguments.length;
	    if (length < 2 || obj == null) { return obj; }
	    for (var index = 1; index < length; index++) {
	      var source = arguments$1[index],
	          keys = Object.keys(source),
	          l = keys.length;
	      for (var i = 0; i < l; i++) {
	        var key = keys[i];
	        if (obj[key] === void 0) { obj[key] = source[key]; }
	      }
	    }
	    return obj;
	  }
	  function stringify(item, options) {
	    var references = [];

	    // Backward compatibility with 0.0.6 that exepects `options` to be a callback.
	    options = typeof options === 'function' ? { prepare: options } : options;
	    options = defaults(options || {}, {
	      prepare: null,
	      isSerializable: function(item, key) {
	        return item.hasOwnProperty(key);
	      }
	    });

	    var root = cloneWithReferences(item, references, options);

	    return JSON.stringify({
	      root: root,
	      references: references
	    });
	  }

	  function cloneWithReferences(item, references, options, savedItems) {
	    // invoke callback before any operations related to serializing the item
	    if (options.prepare) { options.prepare(item); }

	    savedItems = savedItems || [];
	    var type = typeOf(item);

	    // can this object contain its own properties?
	    if (CONTAINER_TYPES.indexOf(type) !== -1) {
	      var referenceIndex = savedItems.indexOf(item);
	      // do we need to store a new reference to this object?
	      if (referenceIndex === -1) {
	        var clone = {};
	        referenceIndex = references.push({
	          contents: clone,
	          value: wrapConstructor(item)
	        }) - 1;
	        savedItems[referenceIndex] = item;
	        for (var key in item) {
	          if (options.isSerializable(item, key)) {
	            clone[key] = cloneWithReferences(item[key], references, options, savedItems);
	          }
	        }
	      }

	      // return something like _CRYO_REF_22
	      return REFERENCE_FLAG + referenceIndex;
	    }

	    // return a non-container object
	    return wrap(item);
	  }

	  function parse(string, options) {
	    var json = JSON.parse(string);

	    // Backward compatibility with 0.0.6 that exepects `options` to be a callback.
	    options = typeof options === 'function' ? { finalize: options } : options;
	    options = defaults(options || {}, { finalize: null });

	    return rebuildFromReferences(json.root, json.references, options);
	  }

	  function rebuildFromReferences(item, references, options, restoredItems) {
	    restoredItems = restoredItems || [];
	    if (starts(item, REFERENCE_FLAG)) {
	      var referenceIndex = parseInt(item.slice(REFERENCE_FLAG.length), 10);
	      if (!restoredItems.hasOwnProperty(referenceIndex)) {
	        var ref = references[referenceIndex];
	        var container = unwrapConstructor(ref.value);
	        var contents = ref.contents;
	        restoredItems[referenceIndex] = container;
	        for (var key in contents) {
	          container[key] = rebuildFromReferences(contents[key], references, options, restoredItems);
	        }
	      }

	      // invoke callback after all operations related to serializing the item
	      if (options.finalize) { options.finalize(restoredItems[referenceIndex]); }

	      return restoredItems[referenceIndex];
	    }

	    // invoke callback after all operations related to serializing the item
	    if (options.finalize) { options.finalize(item); }

	    return unwrap(item);
	  }

	  function wrap(item) {
	    var type = typeOf(item);
	    if (type === 'undefined') { return UNDEFINED_FLAG; }
	    if (type === 'function') { return FUNCTION_FLAG + item.toString(); }
	    if (type === 'date') { return DATE_FLAG + item.getTime(); }
	    if (item === Infinity) { return INFINITY_FLAG; }
	    if (type === 'dom') { return undefined; }
	    return item;
	  }

	  function wrapConstructor(item) {
	    var type = typeOf(item);
	    if (type === 'function' || type === 'date') { return wrap(item); }
	    if (type === 'object') { return OBJECT_FLAG; }
	    if (type === 'array') { return ARRAY_FLAG; }
	    return item;
	  }

	  function unwrapConstructor(val) {
	    if (typeOf(val) === 'string') {
	      if (val === UNDEFINED_FLAG) { return undefined; }
	      if (starts(val, FUNCTION_FLAG)) {
	        return (new Function("return " + val.slice(FUNCTION_FLAG.length)))();
	      }
	      if (starts(val, DATE_FLAG)) {
	        var dateNum = parseInt(val.slice(DATE_FLAG.length), 10);
	        return new Date(dateNum);
	      }
	      if (starts(val, OBJECT_FLAG)) {
	        return {};
	      }
	      if (starts(val, ARRAY_FLAG)) {
	        return [];
	      }
	      if (val === INFINITY_FLAG) { return Infinity; }
	    }
	    return val;
	  }

	  function unwrap(val) {
	    if (typeOf(val) === 'string') {
	      if (val === UNDEFINED_FLAG) { return undefined; }
	      if (starts(val, FUNCTION_FLAG)) {
	        var fn = val.slice(FUNCTION_FLAG.length);
	        var argStart = fn.indexOf('(') + 1;
	        var argEnd = fn.indexOf(')', argStart);
	        var args = fn.slice(argStart, argEnd);
	        var bodyStart = fn.indexOf('{') + 1;
	        var bodyEnd = fn.lastIndexOf('}') - 1;
	        var body = fn.slice(bodyStart, bodyEnd);
	        return new Function(args, body);
	      }
	      if (starts(val, DATE_FLAG)) {
	        var dateNum = parseInt(val.slice(DATE_FLAG.length), 10);
	        return new Date(dateNum);
	      }
	      if (val === INFINITY_FLAG) { return Infinity; }
	    }
	    return val;
	  }

	  function starts(string, prefix) {
	    return typeOf(string) === 'string' && string.slice(0, prefix.length) === prefix;
	  }

	  // Exported object
	  var Cryo = {
	    stringify: stringify,
	    parse: parse
	  };

	  // global on server, window in browser
	  var root = this;

	  // AMD / RequireJS
	  if (typeof undefined !== 'undefined' && undefined.amd) {
	    undefined('Cryo', [], function () {
	      return Cryo;
	    });
	  }

	  // node.js
	  else if ('object' !== 'undefined' && module.exports) {
	    module.exports = Cryo;
	  }

	  // included directly via <script> tag
	  else {
	    root.Cryo = Cryo;
	  }

	})();
	});

	var client$1 = function(ref){
	  if ( ref === void 0 ) ref = {};
	  var socket = ref.socket; if ( socket === void 0 ) socket = nanosocket();

	  socket.id = 0;

	  var xrs = emitterify({ 
	    socket: socket
	  , send: send(socket)
	  , get subscriptions(){
	      return values(socket.on)
	        .map(function (d) { return d && d[0]; })
	        .filter(function (d) { return d && d.type && d.type[0] == '$'; })
	    }
	  });
	  
	  socket
	    .once('disconnected')
	    .map(function (d) { return socket
	      .on('connected')
	      .map(reconnect(xrs)); }
	    );

	  socket
	    .on('recv')
	    .map(function (d) { return parse$2(d); })
	    .each(function (ref) {
	      var id = ref.id;
	      var data = ref.data;
	      var server = ref.server;

	      // TODO: check/warn if no sub
	      var sink = socket.on[("$" + id)] && socket.on[("$" + id)][0];

	      server    ? xrs.emit('recv', { id: id, data: data, server: server })
	    : data.exec ? data.exec(sink, data.value)
	                : socket.emit(("$" + id), data);
	    });

	  return xrs
	};

	var reconnect = function (xrs) { return function () { return xrs.subscriptions
	  // .map(d => d.type)
	  .map(function (ref) {
	    var subscription = ref.subscription;

	    return xrs.socket.send(subscription);
	  }); }; };

	var parse$2 = cryo.parse;

	var send = function (socket, type) { return function (data, meta) {
	  if (data instanceof window.Blob) 
	    { return binary(socket, data, meta) }

	  var id = str(++socket.id)
	      , output = socket.on(("$" + id))
	      , next = function (data, count) {
	        if ( count === void 0 ) count = 0;

	        return socket
	          .send(output.source.subscription = str({ id: id, data: data, type: type }))
	          .then(function (d) { return output.emit('sent', { id: id, count: count }); });
	  };

	  data.next 
	    ? data.map(next).source.emit('start')
	    : next(data);

	  output
	    .source
	    .once('stop')
	    .filter(function (reason) { return reason != 'CLOSED'; })
	    .map(function (d) { return send(socket, 'UNSUBSCRIBE')(id)
	      // TODO: also force stop on close of server created sub (?)
	      .filter(function (d, i, n) { return n.source.emit('stop', 'CLOSED'); }); }
	    );

	  return output
	}; };

	var binary = function (socket, blob, meta, start, blockSize) {
	  if ( start === void 0 ) start = 0;
	  if ( blockSize === void 0 ) blockSize = 1024;

	  var output = emitterify().on('recv')
	      , next = function (id) { return function () { return start >= blob.size 
	            ? output.emit('sent', { id: id })
	            : ( socket.send(blob.slice(start, start += blockSize)), window.setTimeout(next(id))); }; };

	  send(socket, 'BINARY')({ size: blob.size, meta: meta })
	    .on('sent', function (ref) {
	      var id = ref.id;

	      return next(id)();
	  })
	    .on('progress', function (received) { return output.emit('progress', { received: received, total: blob.size }); })
	    .map(output.next)
	    .source
	    .until(output.once('stop'));

	  return output
	};

	var time = function time(ms, fn) {
	  return arguments.length === 1 
	       ? setTimeout(ms)
	       : setTimeout(fn, ms)
	};

	var client$2 = function sync(
	  ripple
	, ref
	, ref$1
	){
	  if ( ref === void 0 ) ref = {};
	  if ( ref$1 === void 0 ) ref$1 = {};
	  var xrs = ref$1.xrs; if ( xrs === void 0 ) xrs = client$1;

	  ripple.server = xrs();
	  ripple.send = send$1(ripple);
	  ripple.subscribe = subscribe(ripple);
	  ripple.subscriptions = {};
	  ripple.get = get(ripple);
	  ripple.upload = upload(ripple);
	  ripple.upload.id = 0;

	  // TODO: other than cache pushes? ans: use server.type
	  ripple
	    .server
	    .on('recv')
	    .map(function (ref, i, n) {
	      var data = ref.data;
	      var server = ref.server;

	      return cache(ripple, server.name)(data, i, n);
	  });

	  return ripple
	};

	var send$1 = function (ref) {
	  var server = ref.server;

	  return function (name, type, value) { return name instanceof Blob ? server.send(name, type)
	: is_1.obj(name)         ? server.send(name)
	                       : server.send({ name: name, type: type, value: value }); };
	};

	var get = function (ripple) { return function (name, k) { return ripple
	  .subscribe(name, k)
	  .filter(function (d, i, n) { return n.source.emit('stop'); })
	  .start(); }; };

	var cache = function (ripple, name, k) { return function (change, i, n) {
	  if (change.name && name != change.name) { ripple.link(name, change.name); }
	  if (is_1.def(k)) { change.key = k + "." + (str(change.key)); }
	  !change.key && change.type == 'update'
	    ? ripple(body(extend({ name: name })(change)))
	    : set(change)(ripple.resources[name] ? ripple(name) : ripple(name, {}));

	  ripple.change = assign({ name: name }, change);
	  // TODO: change.key or key here?
	  return key(k)(ripple(name))
	}; };

	var subscribe = function (ripple) { return function (name, k) {
	  if (is_1.arr(name)) { return merge$1(name.map(function (n) { return ripple.subscribe(n, k); }))
	    .map(function (d) { return name.reduce(function (p, v, i) { return (p[v] = d[i], p); }, {}); }) }

	  ripple.subscriptions[name] = ripple.subscriptions[name] || {};
	  if (is_1.arr(k)) { return merge$1(k.map(function (k) { return ripple.subscribe(name, k); }))
	    .map(function (d) { return key(k)(ripple(name)); }) }
	  var output = emitterify().on('subscription');

	  output
	    .on('stop')
	    .each(function (d, i, n) {
	      raw.subs.splice(raw.subs.indexOf(output), 1);
	      time(1000, function () { 
	        if (raw.subs.length) { return }
	        raw.source.emit('stop');
	        ripple.subscriptions[name][k] = undefined;
	        output.emit('end');
	      });
	    });

	  if (ripple.subscriptions[name][k])
	    { output
	      .on('start')
	      .map(function () { return key(k)(ripple(name)); })
	      .filter(is_1.def)
	      .map(function (initial) { return output.next(initial); }); }

	  var raw = ripple.subscriptions[name][k] = ripple.subscriptions[name][k] || ripple
	    .send(name, 'SUBSCRIBE', k)
	    .map(cache(ripple, name, k))
	    .each(function (value) {
	      raw.subs.map(function (o) { return o.next(value); });
	      delete ripple.change;
	    });

	  raw.subs = raw.subs || [];
	  raw.subs.push(output);
	  
	  return output
	}; };

	var upload = function (ripple) { return function (name, form) {
	  var index = ++ripple.upload.id
	    , fields = {}
	    , size = 0
	    , next = function () {
	        if (!files.length) { return true }
	        var ref = files.shift();
	        var field = ref.field;
	        var filename = ref.filename;
	        var i = ref.i;
	        var blob = ref.blob;
	        return ripple
	          .send(blob, { filename: filename, field: field, i: i, index: index })
	          .on('progress', function (ref) {
	            var received = ref.received;
	            var total = ref.total;

	            return output.emit('progress', {
	            total: size
	          , received: 
	              size
	            - (blob.size - received)
	            - files.reduce(function (acc, d) { return (acc += d.blob.size); }, 0)
	          });
	        })
	          .then(next)
	      };

	  var files = keys(form)
	    .map(function (field) { return (fields[field] = form[field], field); })
	    .filter(function (field) { return form[field] instanceof FileList; })
	    .map(function (field) { 
	      fields[field] = [];
	      return to.arr(form[field])
	        .map(function (f) { return (size += f.size, f); })
	        .map(function (f, i) { return ({ field: field, filename: f.name, i: i, blob: f, sent: 0 }); })
	    })
	    .reduce(flatten, []);

	  var output = ripple.send({ 
	    files: files.length
	  , type: 'PREUPLOAD'
	  , fields: fields
	  , index: index
	  , size: size 
	  , name: name
	  }).once('sent', next);

	  return output
	}; };

	var body = function (ref) {
	  var name = ref.name;
	  var value = ref.value;
	  var headers = ref.headers;

	  return ({ name: name, headers: headers, body: value });
	};
	var assign = Object.assign;

	// TODO: factor out
	var merge$1 = function (streams) {
	  var output = emitterify().on('merged');
	  output.streams = streams;

	  streams.map(function (stream, i) { return stream.each(function (value) {
	      stream.latest = value;
	      var latest = streams.map(function (d) { return d.latest; });
	      if (latest.every(is_1.def)) { output.next(latest); }
	    }); }
	  );

	  output
	    .once('start')
	    .map(function (d) { return streams.map(function ($) { return $.source.emit('start'); }); });

	  output
	    .once('stop')
	    .map(function (d) { return streams.map(function ($) { return $.source.emit('stop'); }); });

	  return output
	};

	var ready = function ready(fn){
	  return document.body ? fn() : document.addEventListener('DOMContentLoaded', fn.bind(this))
	};

	var _class = function (definition) { return assign$1(
	   definition.class               ? definition.class
	: !definition.prototype           ? classed(definition)
	:  definition.prototype.render    ? definition
	:  definition.prototype.connected ? definition
	                                  : classed(definition)
	); };

	var assign$1 = Object.assign;

	var classed = function (render) { return render.class = render.class || class { 
	  render(){ render.apply(this, arguments); } 
	}; };

	var event = function event(node, index) {
	  node = node.host && node.host.nodeName ? node.host : node;
	  if (node.on) { return }
	  node.listeners = {};

	  var on = function (o) {
	    var type = o.type.split('.').shift();
	    if (!node.listeners[type])
	      { node.addEventListener(type, node.listeners[type] = 
	        function (event) { return (!event.detail || !event.detail.emitted ? emit(type, event) : 0); }
	      ); }
	  };

	  var off = function (o) {
	    if (!node.on[o.type].length) {
	      node.removeEventListener(o.type, node.listeners[o.type]);
	      delete node.listeners[o.type];
	    }
	  };

	  emitterify(node, { on: on, off: off });
	  var emit = node.emit;

	  node.emit = function(type, params){
	    var detail = { params: params, emitted: true }
	        , event = new CustomEvent(type, { detail: detail, bubbles: false, cancelable: true });
	    node.dispatchEvent(event);
	    return emit(type, event)
	  };
	};

	var noop$1 = function () {}
	    , HTMLElement = client && window.HTMLElement || class {}
	    , registry = client && window.customElements || {};

	var define = function define(name, component) {
	  if (arguments.length == 1) { component = name, name = "anon-" + (registry.anon++); }
	  if (component.wrapper) { return component.wrapper }
	  if (!name.includes('-')) { return; }
	  if (!client) { return wrap$1(_class(component)) }
	  var wrapped = registry.get(name);

	  if (wrapped) {
	    if (wrapped.class == _class(component)) { return wrapped }
	    wrapped.class = _class(component);
	    var instances = Array.from(document.querySelectorAll(name));
	    instances.map(function (node) {
	      node.disconnectedCallback();
	      node.methods.map(function (method) { delete node[method]; });
	      node.connectedCallback();
	    });
	  } else {
	    registry.define(name, wrapped = wrap$1(_class(component)));
	  }

	  return wrapped
	};

	var wrap$1 = function (component) {
	  component.wrapper = component.wrapper || class extends HTMLElement {
	    connectedCallback(){
	      var this$1 = this;
	 
	      var ref = component.wrapper.class;
	      var prototype = ref.prototype;
	      event(this);
	      this.state = this.state || {};
	      this.methods = Object
	        .getOwnPropertyNames(prototype)
	        .filter(function (method) { return !(method in disallowed); })
	        .map(function (method) { return (this$1[method] = prototype[method].bind(this$1), method); });

	      return Promise.resolve((this.connected || noop$1).call(this, this, this.state))
	        .then(function (d) {
	          this$1.initialised = true;
	          this$1.render();
	        })
	    }

	    render(){
	      var ref = component.wrapper.class;
	      var prototype = ref.prototype;
	      if (!this.initialised) { return }
	      return prototype.render.call(this, this, this.state)
	    }

	    disconnectedCallback(){
	      (this.disconnected || noop$1).call(this, this, this.state);
	      this.dispatchEvent(new CustomEvent('disconnected')); 
	      this.initialised = false;
	    }
	  };

	  component.wrapper.class = component;
	  return component.wrapper
	};

	var disallowed = { length: 1, prototype: 1, name: 1, render: 1 };

	registry.anon = registry.anon || 1;

	var rijs_components = function components(ripple){
	  if (!client) { return ripple }
	  log$6('creating');

	  // if no render is defined on a component, load up definition
	  Node.prototype.render = function(){
	    var name = this.nodeName.toLowerCase();
	    if (name.includes('-')) 
	      { this.fn$ = this.fn$ || ripple
	        .subscribe(name)
	        .map(function (component) { return define(name, component); }); }
	        // .until(new Promise(resolve => this.addEventListener('disconnected', () => {
	        //   if (!this.isConnected) resolve()
	        // })))
	  };
	  
	  // this is for backwards compatibility
	  Node.prototype.draw = function(){ 
	    this.render(); 
	  };

	  ready(function () { return Array.from(document.querySelectorAll('*'))
	    .filter(function (d) { return d.nodeName.includes('-'); })
	    .map(function (node) { return node.render(); }); }
	  );

	  return ripple
	};

	var log$6 = log('[ri/components]');

	var ripple = createCommonjsModule(function (module) {
	function create(opts) {
	    var ripple = rijs_core(opts);
	    return rijs_singleton(ripple, opts), rijs_data(ripple, opts), client_1(ripple, opts), client_1$1(ripple, opts), client$2(ripple, opts), rijs_components(ripple, opts), ripple;
	}

	!window.ripple && create(), module.exports = create;
	});

	return ripple;

}());