(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);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.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})({1:[function(require,module,exports){
var TreeDispatcher, TreePersistence;

TreeDispatcher = require('../dispatcher/Dispatcher.coffee');

TreePersistence = require('../persistence/TreePersistence.coffee');

module.exports = {
  loadPath: function(path, data) {
    return TreeDispatcher.handleServerAction({
      path: path,
      data: data,
      type: "loadPath"
    });
  },
  loadSein: function(path, data) {
    return TreeDispatcher.handleServerAction({
      path: path,
      data: data,
      type: "loadSein"
    });
  },
  clearData: function() {
    TreePersistence.refresh();
    return TreeDispatcher.handleServerAction({
      type: "clearData"
    });
  },
  sendQuery: function(path, query) {
    if (query == null) {
      return;
    }
    if (path.slice(-1) === "/") {
      path = path.slice(0, -1);
    }
    return TreePersistence.get(path, query, (function(_this) {
      return function(err, res) {
        if (err != null) {
          throw err;
        }
        return _this.loadPath(path, res);
      };
    })(this));
  },
  registerComponent: function(name, comp) {
    var obj;
    return this.addVirtual((
      obj = {},
      obj["" + name] = comp,
      obj
    ));
  },
  addVirtual: function(components) {
    return TreeDispatcher.handleViewAction({
      type: "addVirtual",
      components: components
    });
  },
  addComment: function(pax, txt) {
    if (pax[0] !== "/") {
      pax = "/" + pax;
    }
    return TreePersistence.put({
      pax: pax,
      txt: txt
    }, "talk-comment");
  },
  setPlanInfo: function(arg) {
    var loc, who;
    who = arg.who, loc = arg.loc;
    return TreePersistence.put({
      who: who,
      loc: loc
    }, "write-plan-info", "hood");
  },
  setCurr: function(path) {
    return TreeDispatcher.handleViewAction({
      type: "setCurr",
      path: path
    });
  },
  setNav: function(arg) {
    var dpad, sibs, subnav, title;
    title = arg.title, dpad = arg.dpad, sibs = arg.sibs, subnav = arg.subnav;
    return TreeDispatcher.handleViewAction({
      title: title,
      dpad: dpad,
      sibs: sibs,
      subnav: subnav,
      type: "setNav"
    });
  },
  toggleNav: function() {
    return TreeDispatcher.handleViewAction({
      type: "toggleNav"
    });
  },
  closeNav: function() {
    return TreeDispatcher.handleViewAction({
      type: "closeNav"
    });
  },
  clearNav: function() {
    return TreeDispatcher.handleViewAction({
      type: "clearNav"
    });
  }
};


},{"../dispatcher/Dispatcher.coffee":22,"../persistence/TreePersistence.coffee":24}],2:[function(require,module,exports){
var TreeActions, TreeStore, _load, code, div, fragsrc, recl, ref, span, util;

util = require('../utils/util.coffee');

_load = require('./LoadComponent.coffee');

TreeStore = require('../stores/TreeStore.coffee');

TreeActions = require('../actions/TreeActions.coffee');

recl = React.createClass;

ref = React.DOM, div = ref.div, span = ref.span, code = ref.code;

fragsrc = function(src, basePath) {
  var base, pathname;
  if (src != null) {
    basePath = util.basepath(basePath);
    if (basePath.slice(-1) !== "/") {
      basePath += "/";
    }
    base = new URL(basePath, document.location);
    pathname = new URL(src, base).pathname;
    return util.fragpath(pathname);
  }
};

module.exports = function(queries, Child, load) {
  if (load == null) {
    load = _load;
  }
  return recl({
    displayName: "Async",
    getInitialState: function() {
      return this.stateFromStore();
    },
    _onChangeStore: function() {
      if (this.isMounted()) {
        return this.setState(this.stateFromStore());
      }
    },
    getPath: function() {
      var base, path, ref1, ref2;
      path = this.props.dataPath;
      base = (ref1 = this.props.basePath) != null ? ref1 : TreeStore.getCurr();
      if (path == null) {
        path = (ref2 = fragsrc(this.props.src, base)) != null ? ref2 : base;
      }
      if (path.slice(-1) === "/") {
        return path.slice(0, -1);
      } else {
        return path;
      }
    },
    stateFromStore: function() {
      var fresh, got, path;
      path = this.getPath();
      fresh = TreeStore.fulfill(path, queries);
      if (!((this.state != null) && path === this.state.path)) {
        got = fresh;
      } else {
        got = this.mergeWith(this.state.got, fresh);
      }
      return {
        path: path,
        fresh: fresh,
        got: got
      };
    },
    mergeWith: function(have, fresh, _queries) {
      var got, k, kid, ref1, ref2, ref3;
      if (have == null) {
        have = {};
      }
      if (fresh == null) {
        fresh = {};
      }
      if (_queries == null) {
        _queries = queries;
      }
      got = {};
      for (k in _queries) {
        if (k !== 'kids') {
          got[k] = (ref1 = fresh[k]) != null ? ref1 : have[k];
        }
      }
      if (_queries.kids != null) {
        if (fresh.kids == null) {
          got.kids = have.kids;
        } else {
          got.kids = {};
          ref2 = fresh.kids;
          for (k in ref2) {
            kid = ref2[k];
            got.kids[k] = this.mergeWith((ref3 = have.kids) != null ? ref3[k] : void 0, kid, _queries.kids);
          }
        }
      }
      return got;
    },
    componentDidMount: function() {
      TreeStore.addChangeListener(this._onChangeStore);
      return this.checkPath();
    },
    componentWillUnmount: function() {
      return TreeStore.removeChangeListener(this._onChangeStore);
    },
    componentDidUpdate: function(_props, _state) {
      if (_props !== this.props) {
        this.setState(this.stateFromStore());
      }
      return this.checkPath();
    },
    checkPath: function() {
      return TreeActions.sendQuery(this.getPath(), this.filterFreshQueries());
    },
    filterFreshQueries: function() {
      return this.filterWith(this.state.fresh, queries);
    },
    filterQueries: function() {
      return this.filterWith(this.state.got, queries);
    },
    filterWith: function(have, _queries) {
      var k, kid, ref1, request;
      if (have == null) {
        return _queries;
      }
      request = {};
      for (k in _queries) {
        if (k !== 'kids') {
          if (have[k] === void 0) {
            request[k] = _queries[k];
          }
        }
      }
      if (_queries.kids != null) {
        if (have.kids == null) {
          request.kids = _queries.kids;
        } else {
          request.kids = {};
          ref1 = have.kids;
          for (k in ref1) {
            kid = ref1[k];
            _.merge(request.kids, this.filterWith(kid, _queries.kids));
          }
          if (_.isEmpty(request.kids)) {
            delete request.kids;
          }
        }
      }
      if (!_.isEmpty(request)) {
        return request;
      }
    },
    scrollHash: function() {
      var ref1;
      return (ref1 = this.getHashElement()) != null ? ref1.scrollIntoView() : void 0;
    },
    getHashElement: function() {
      var hash;
      hash = document.location.hash;
      if (hash) {
        return document.getElementById(hash.slice(1));
      }
    },
    render: function() {
      return div({}, this.filterQueries() != null ? React.createElement(load, this.props) : (!this.getHashElement() ? setTimeout(this.scrollHash, 0) : void 0, React.createElement(Child, _.extend({}, this.props, this.state.got), this.props.children)));
    }
  });
};


},{"../actions/TreeActions.coffee":1,"../stores/TreeStore.coffee":25,"../utils/util.coffee":27,"./LoadComponent.coffee":11}],3:[function(require,module,exports){
var Comments, TreeActions, TreeStore, a, clas, div, extras, h1, h3, img, input, load, p, query, reactify, recl, ref, rele, util;

clas = require('classnames');

load = require('./LoadComponent.coffee');

query = require('./Async.coffee');

reactify = require('./Reactify.coffee');

TreeActions = require('../actions/TreeActions.coffee');

TreeStore = require('../stores/TreeStore.coffee');

Comments = require('./CommentsComponent.coffee');

util = require('../utils/util.coffee');

recl = React.createClass;

rele = React.createElement;

ref = React.DOM, div = ref.div, h1 = ref.h1, h3 = ref.h3, p = ref.p, img = ref.img, a = ref.a, input = ref.input;

extras = {
  spam: recl({
    displayName: "Spam",
    render: function() {
      if (document.location.hostname !== 'urbit.org') {
        return div({});
      }
      return div({
        className: 'spam'
      }, a({
        href: "http://urbit.org#sign-up"
      }, "Sign up"), " for our newsletter.");
    }
  }),
  logo: recl({
    displayName: "Logo",
    render: function() {
      var color, src;
      color = this.props.color;
      if (color === "white" || color === "black") {
        src = "//storage.googleapis.com/urbit-extra/logo/logo-" + color + "-100x100.png";
      }
      return a({
        href: "http://urbit.org",
        style: {
          border: "none"
        }
      }, img({
        src: src,
        className: "logo first"
      }));
    }
  }),
  date: recl({
    displayName: "Date",
    render: function() {
      return div({
        className: 'date'
      }, this.props.date);
    }
  }),
  title: recl({
    displayName: "Title",
    render: function() {
      return h1({
        className: 'title'
      }, this.props.title);
    }
  }),
  image: recl({
    displayName: "Image",
    render: function() {
      return img({
        src: this.props.image
      }, "");
    }
  }),
  preview: recl({
    displayName: "Preview",
    render: function() {
      return p({
        className: 'preview'
      }, this.props.preview);
    }
  }),
  author: recl({
    displayName: "Author",
    render: function() {
      return h3({
        className: 'author'
      }, this.props.author);
    }
  }),
  next: query({
    path: 't',
    kids: {
      name: 't',
      head: 'r',
      meta: 'j'
    }
  }, recl({
    displayName: "Next",
    render: function() {
      var curr, index, keys, next, ref1;
      curr = this.props.kids[this.props.curr];
      if (curr != null ? (ref1 = curr.meta) != null ? ref1.next : void 0 : void 0) {
        keys = util.getKeys(this.props.kids);
        if (keys.length > 1) {
          index = keys.indexOf(this.props.curr);
          next = index + 1;
          if (next === keys.length) {
            next = 0;
          }
          next = keys[next];
          next = this.props.kids[next];
          if (next) {
            return div({
              className: "link-next"
            }, a({
              href: this.props.path + "/" + next.name
            }, "Next: " + next.meta.title));
          }
        }
      }
      return div({}, "");
    }
  })),
  comments: Comments,
  footer: recl({
    displayName: "Footer",
    render: function() {
      var containerClas, footerClas;
      containerClas = clas({
        footer: true,
        container: this.props.container === 'false'
      });
      footerClas = clas({
        'col-md-12': this.props.container === 'false'
      });
      return div({
        className: containerClas,
        key: 'footer-container'
      }, [
        div({
          className: footerClas,
          key: 'footer-inner'
        }, [
          "This page was made by Urbit. ", a({
            href: "urbit.org"
          }, "urbit.org"), a({
            href: "mailto:urbit@urbit.org"
          }, "contact")
        ])
      ]);
    }
  })
};

module.exports = query({
  body: 'r',
  name: 't',
  path: 't',
  meta: 'j',
  sein: 't'
}, recl({
  displayName: "Body",
  stateFromStore: function() {
    return {
      curr: TreeStore.getCurr()
    };
  },
  getInitialState: function() {
    return this.stateFromStore();
  },
  _onChangeStore: function() {
    if (this.isMounted()) {
      return this.setState(this.stateFromStore());
    }
  },
  componentDidMount: function() {
    return TreeStore.addChangeListener(this._onChangeStore);
  },
  render: function() {
    var bodyClas, extra, innerClas, parts, ref1;
    extra = (function(_this) {
      return function(name, props) {
        if (props == null) {
          props = {};
        }
        if (_this.props.meta[name] != null) {
          if ((_.keys(props)).length === 0) {
            props[name] = _this.props.meta[name];
          }
          props.key = name;
          return React.createElement(extras[name], props);
        }
      };
    })(this);
    innerClas = {
      body: true
    };
    if (this.props.meta.anchor !== 'none' && this.props.meta.navmode !== 'navbar') {
      innerClas['col-md-9'] = true;
      innerClas['col-md-offset-3'] = true;
    }
    if (this.props.meta.navmode === 'navbar' && this.props.meta.container !== 'false') {
      innerClas['col-md-9'] = true;
      innerClas['col-md-offset-1'] = true;
    }
    innerClas = clas(innerClas);
    bodyClas = clas((ref1 = this.props.meta.layout) != null ? ref1.split(',') : void 0);
    if (this.props.meta.type && bodyClas.indexOf(this.props.meta.type) === -1) {
      bodyClas += " " + this.props.meta.type;
    }
    parts = [
      extra('spam'), extra('logo', {
        color: this.props.meta.logo
      }), reactify(this.props.body, 'body'), extra('next', {
        dataPath: this.props.sein,
        curr: this.props.name
      }), extra('comments'), extra('footer', {
        container: this.props.meta.container
      })
    ];
    if (this.props.meta.type === "post") {
      parts.splice(1, 0, extra('date'), extra('title'), extra('image'), extra('preview'), extra('author'));
    }
    return div({
      dataPath: this.state.curr,
      key: this.state.curr
    }, [
      div({
        className: innerClas,
        'data-path': this.props.path,
        key: 'body-inner'
      }, [
        div({
          key: "body" + this.props.path,
          id: 'body',
          className: bodyClas
        }, parts)
      ])
    ]);
  }
}), recl({
  render: function() {
    return div({
      id: 'body',
      className: "col-md-offset-3 col-md-9"
    }, rele(load));
  }
}));


},{"../actions/TreeActions.coffee":1,"../stores/TreeStore.coffee":25,"../utils/util.coffee":27,"./Async.coffee":2,"./CommentsComponent.coffee":5,"./LoadComponent.coffee":11,"./Reactify.coffee":16,"classnames":28}],4:[function(require,module,exports){
var div, recl, ref, textarea;

recl = React.createClass;

ref = React.DOM, div = ref.div, textarea = ref.textarea;

module.exports = recl({
  render: function() {
    return div({}, textarea({
      ref: 'ed',
      value: this.props.value
    }));
  },
  componentDidMount: function() {
    return CodeMirror.fromTextArea(ReactDOM.findDOMNode(this.refs.ed), {
      readOnly: true,
      lineNumbers: true
    });
  }
});


},{}],5:[function(require,module,exports){
var Comment, TreeActions, a, clas, div, form, img, input, load, p, query, reactify, recl, ref, rele, textarea, util;

clas = require('classnames');

load = require('./LoadComponent.coffee');

query = require('./Async.coffee');

reactify = require('./Reactify.coffee');

TreeActions = require('../actions/TreeActions.coffee');

util = require('../utils/util.coffee');

recl = React.createClass;

rele = React.createElement;

ref = React.DOM, div = ref.div, p = ref.p, img = ref.img, a = ref.a, form = ref.form, textarea = ref.textarea, input = ref.input;

Comment = function(arg) {
  var body, time;
  time = arg.time, body = arg.body;
  return div({
    className: "comment"
  }, "" + (window.urb.util.toDate(new Date(time))), reactify(body));
};

module.exports = query({
  comt: 'j',
  path: 't'
}, recl({
  displayName: "Comments",
  getInitialState: function() {
    return {
      loading: false,
      value: ""
    };
  },
  componentDidUpdate: function(_props) {
    if (this.props.comt.length > _props.comt.length) {
      return this.setState({
        loading: false
      });
    }
  },
  onSubmit: function(e) {
    TreeActions.addComment(this.props.path, this.refs["in"].comment.value);
    this.setState({
      loading: true,
      value: ""
    });
    return e.preventDefault();
  },
  onChange: function(e) {
    return this.setState({
      value: e.target.value
    });
  },
  render: function() {
    var _attr, inputAttr, textareaAttr;
    _attr = {};
    if (this.state.loading === true) {
      _attr.disabled = "true";
    }
    textareaAttr = _.create(_attr, {
      type: "text",
      name: "comment",
      value: this.state.value,
      onChange: this.onChange
    });
    inputAttr = _.create(_attr, {
      type: "submit",
      value: "Add comment",
      className: "btn btn-primary"
    });
    return div({}, div({
      className: "add-comment"
    }, form({
      ref: "in",
      onSubmit: this.onSubmit
    }, textarea(textareaAttr), input(inputAttr))), (this.state.loading === true ? rele(load) : ""), div({
      className: "comments"
    }, this.props.comt.map(function(props, key) {
      return rele(Comment, _.extend({
        key: key
      }, props));
    })));
  }
}));


},{"../actions/TreeActions.coffee":1,"../utils/util.coffee":27,"./Async.coffee":2,"./LoadComponent.coffee":11,"./Reactify.coffee":16,"classnames":28}],6:[function(require,module,exports){
var div, recl;

recl = React.createClass;

div = React.DOM.div;

module.exports = {
  codemirror: require('./CodeMirror.coffee'),
  search: require('./SearchComponent.coffee'),
  list: require('./ListComponent.coffee'),
  kids: require('./KidsComponent.coffee'),
  toc: require('./TocComponent.coffee'),
  email: require('./EmailComponent.coffee'),
  module: require('./ModuleComponent.coffee'),
  script: require('./ScriptComponent.coffee'),
  plan: require('./PlanComponent.coffee'),
  panel: require('./PanelComponent.coffee'),
  lost: recl({
    render: function() {
      return div({}, "<lost(", this.props.children, ")>");
    }
  })
};


},{"./CodeMirror.coffee":4,"./EmailComponent.coffee":8,"./KidsComponent.coffee":9,"./ListComponent.coffee":10,"./ModuleComponent.coffee":12,"./PanelComponent.coffee":14,"./PlanComponent.coffee":15,"./ScriptComponent.coffee":17,"./SearchComponent.coffee":18,"./TocComponent.coffee":20}],7:[function(require,module,exports){
var a, div, recl, ref, util;

util = require('../utils/util.coffee');

recl = React.createClass;

ref = React.DOM, div = ref.div, a = ref.a;

module.exports = recl({
  displayName: "Dpad",
  renderUp: function() {
    if (this.props.sein) {
      return this.renderArrow("up", this.props.sein);
    }
  },
  renderArrow: function(name, path) {
    var href;
    href = util.basepath(path);
    return a({
      href: href,
      key: "" + name,
      className: "" + name
    }, "");
  },
  renderArrows: function() {
    var index, keys, next, prev, sein;
    keys = util.getKeys(this.props.kids);
    if (keys.length > 1) {
      index = keys.indexOf(this.props.curr);
      prev = index - 1;
      next = index + 1;
      if (prev < 0) {
        prev = keys.length - 1;
      }
      if (next === keys.length) {
        next = 0;
      }
      prev = keys[prev];
      next = keys[next];
    }
    if (this.props.sein) {
      sein = this.props.sein;
      if (sein === "/") {
        sein = "";
      }
      return div({}, prev ? this.renderArrow("prev", sein + "/" + prev) : void 0, next ? this.renderArrow("next", sein + "/" + next) : void 0);
    }
  },
  render: function() {
    return div({
      className: 'dpad',
      key: 'dpad'
    }, this.renderUp(), this.renderArrows());
  }
});


},{"../utils/util.coffee":27}],8:[function(require,module,exports){
var button, div, input, p, reactify, recl, ref;

reactify = require('./Reactify.coffee');

recl = React.createClass;

ref = React.DOM, div = ref.div, p = ref.p, button = ref.button, input = ref.input;

module.exports = recl({
  displayName: "email",
  getInitialState: function() {
    return {
      submit: false,
      email: ""
    };
  },
  onClick: function() {
    return this.submit();
  },
  onChange: function(e) {
    var email, valid;
    email = e.target.value;
    this.setState({
      email: e.target.value
    });
    valid = email.indexOf('@') !== -1 && email.indexOf('.') !== -1 && email.length > 7 && email.split(".")[1].length > 1 && email.split("@")[0].length > 0 && email.split("@")[1].length > 4;
    this.$email.toggleClass('valid', valid);
    this.$email.removeClass('error');
    if (e.keyCode === 13) {
      if (valid === true) {
        this.submit();
        e.stopPropagation();
        e.preventDefault();
        return false;
      } else {
        return this.$email.addClass('error');
      }
    }
  },
  submit: function() {
    return $.post(this.props.dataPath, {
      email: this.$email.val()
    }, (function(_this) {
      return function() {
        return _this.setState({
          submit: true
        });
      };
    })(this));
  },
  componentDidMount: function() {
    return this.$email = $('input.email');
  },
  render: function() {
    var cont, ref1, submit;
    if (this.state.submit === false) {
      submit = (ref1 = this.props.submit) != null ? ref1 : "Sign up";
      cont = [
        input({
          key: "field",
          className: "email",
          placeholder: "your@email.com",
          onChange: this.onChange,
          value: this.state.email
        }), button({
          key: "submit",
          className: "submit btn",
          onClick: this.onClick
        }, submit)
      ];
    } else {
      cont = [
        div({
          className: "submitted"
        }, "Got it. Thanks!")
      ];
    }
    return p({
      className: "email",
      id: "sign-up"
    }, cont);
  }
});


},{"./Reactify.coffee":16}],9:[function(require,module,exports){
var a, clas, div, hr, li, query, reactify, recl, ref, ul;

clas = require('classnames');

reactify = require('./Reactify.coffee');

query = require('./Async.coffee');

recl = React.createClass;

ref = React.DOM, div = ref.div, a = ref.a, ul = ref.ul, li = ref.li, hr = ref.hr;

module.exports = query({
  kids: {
    body: 'r',
    meta: 'j',
    path: 't'
  }
}, recl({
  displayName: "Kids",
  render: function() {
    var _k, body, d, elem, k, keyed, keys, kidClas, kidsClas, ref1, ref2, ref3, ref4, sorted, str, v;
    sorted = true;
    keyed = {};
    ref1 = this.props.kids;
    for (k in ref1) {
      v = ref1[k];
      if (this.props.sortBy) {
        if (this.props.sortBy === 'date') {
          if (((ref2 = v.meta) != null ? ref2.date : void 0) == null) {
            sorted = false;
            continue;
          }
          d = v.meta.date.slice(1).split(".");
          if (d.length < 3) {
            sorted = false;
            continue;
          }
          str = d[0] + "-" + d[1] + "-" + d[2];
          if (d.length > 3) {
            str += " " + d[3] + ":" + d[4] + ":" + d[5];
          }
          _k = Number(new Date(str));
          keyed[_k] = k;
        }
      } else {
        if (((ref3 = v.meta) != null ? ref3.sort : void 0) == null) {
          sorted = false;
        }
        keyed[Number((ref4 = v.meta) != null ? ref4.sort : void 0)] = k;
      }
    }
    if (sorted === false) {
      keyed = _.keys(this.props.kids);
    }
    keys = _.keys(keyed).sort();
    if (this.props.sortBy === 'date') {
      keys.reverse();
    }
    kidsClas = clas({
      kids: true
    }, this.props.className);
    kidClas = clas({
      "col-md-4": this.props.grid === 'true'
    });
    return div({
      className: kidsClas,
      key: "kids"
    }, (function() {
      var i, len, ref5, results;
      results = [];
      for (i = 0, len = keys.length; i < len; i++) {
        k = keys[i];
        elem = (ref5 = this.props.kids[keyed[k]]) != null ? ref5 : "";
        body = reactify(elem.body, k, {
          basePath: elem.path
        });
        results.push([
          div({
            key: keyed[k],
            id: keyed[k],
            className: kidClas
          }, body), hr({})
        ]);
      }
      return results;
    }).call(this));
  }
}));


},{"./Async.coffee":2,"./Reactify.coffee":16,"classnames":28}],10:[function(require,module,exports){
var a, clas, div, h1, li, pre, query, reactify, recl, ref, span, ul, util;

clas = require('classnames');

reactify = require('./Reactify.coffee');

query = require('./Async.coffee');

util = require('../utils/util.coffee');

recl = React.createClass;

ref = React.DOM, div = ref.div, pre = ref.pre, span = ref.span, a = ref.a, ul = ref.ul, li = ref.li, h1 = ref.h1;

module.exports = query({
  path: 't',
  kids: {
    snip: 'r',
    head: 'r',
    meta: 'j'
  }
}, recl({
  displayName: "List",
  render: function() {
    var k, kids;
    k = clas({
      list: true
    }, this.props.dataType, {
      "default": this.props['data-source'] === 'default'
    }, this.props.className);
    kids = this.renderList();
    if (!(kids.length === 0 && (this.props.is404 != null))) {
      return ul({
        className: k
      }, kids);
    }
    return div({
      className: k
    }, h1({
      className: 'red inverse block error'
    }, 'Error: Empty path'), div({}, pre({}, this.props.path), span({}, 'is either empty or does not exist.')));
  },
  renderList: function() {
    var _date, _k, _keys, author, date, elem, href, i, image, item, k, len, linked, node, parts, path, preview, ref1, ref2, ref3, ref4, ref5, ref6, results, sorted, title, v;
    sorted = true;
    _keys = [];
    ref1 = this.props.kids;
    for (k in ref1) {
      v = ref1[k];
      if (this.props.sortBy) {
        if (this.props.sortBy === 'date') {
          if (((ref2 = v.meta) != null ? ref2.date : void 0) == null) {
            sorted = false;
          }
          _k = Number(v.meta.date.slice(1).replace(/\./g, ""));
          _keys[_k] = k;
        }
      } else {
        if (((ref3 = v.meta) != null ? ref3.sort : void 0) == null) {
          sorted = false;
        }
        _keys[Number((ref4 = v.meta) != null ? ref4.sort : void 0)] = k;
      }
    }
    if (this.props.sortBy === 'date') {
      _keys.reverse();
    }
    if (sorted !== true) {
      _keys = _.keys(this.props.kids).sort();
    }
    if (this.props.dataType === 'post') {
      _keys = _keys.reverse();
    }
    ref5 = _.values(_keys);
    results = [];
    for (i = 0, len = ref5.length; i < len; i++) {
      item = ref5[i];
      path = this.props.path + "/" + item;
      elem = this.props.kids[item];
      if (elem.meta.hide != null) {
        continue;
      }
      href = util.basepath(path);
      if (this.props.linkToFragments != null) {
        href = "#" + item;
      }
      if (this.props.childIsFragment != null) {
        href = (util.basepath(this.props.path)) + "#" + item;
      }
      if (elem.meta.link) {
        href = elem.meta.link;
      }
      parts = [];
      title = null;
      if ((ref6 = elem.meta) != null ? ref6.title : void 0) {
        if (this.props.dataType === 'post') {
          title = {
            gn: 'a',
            ga: {
              href: href
            },
            c: [
              {
                gn: 'h1',
                ga: {
                  className: 'title'
                },
                c: [elem.meta.title]
              }
            ]
          };
        } else {
          title = {
            gn: 'h1',
            ga: {
              className: 'title'
            },
            c: [elem.meta.title]
          };
        }
      }
      if (!title && elem.head.c.length > 0) {
        title = elem.head;
      }
      if (!title) {
        title = {
          gn: 'h1',
          ga: {
            className: 'title'
          },
          c: [item]
        };
      }
      if (!this.props.titlesOnly) {
        _date = elem.meta.date;
        if (!_date || _date.length === 0) {
          _date = "";
        }
        date = {
          gn: 'div',
          ga: {
            className: 'date'
          },
          c: [_date]
        };
        parts.push(date);
      }
      parts.push(title);
      if (!this.props.titlesOnly) {
        if (this.props.dataType === 'post') {
          if (elem.meta.image) {
            image = {
              gn: 'a',
              ga: {
                href: href
              },
              c: [
                {
                  gn: 'img',
                  ga: {
                    src: elem.meta.image
                  }
                }
              ]
            };
            parts.push(image);
          }
        }
        if (this.props.dataPreview) {
          if (!elem.meta.preview) {
            parts.push.apply(parts, elem.snip.c.slice(0, 2));
          } else {
            if (elem.meta.preview) {
              preview = {
                gn: 'p',
                ga: {
                  className: 'preview'
                },
                c: [elem.meta.preview]
              };
            } else {
              preview = elem.snip;
            }
            parts.push(preview);
          }
        }
        if (this.props.dataType === 'post') {
          if (elem.meta.author) {
            author = {
              gn: 'h3',
              ga: {
                className: 'author'
              },
              c: [elem.meta.author]
            };
            parts.push(author);
          }
          linked = true;
        }
      }
      node = reactify({
        gn: 'div',
        c: parts
      });
      if (linked == null) {
        node = a({
          href: href,
          className: clas({
            preview: this.props.dataPreview != null
          })
        }, node);
      }
      results.push(li({
        key: item
      }, node));
    }
    return results;
  }
}));


},{"../utils/util.coffee":27,"./Async.coffee":2,"./Reactify.coffee":16,"classnames":28}],11:[function(require,module,exports){
var div, recl, ref, span;

recl = React.createClass;

ref = React.DOM, span = ref.span, div = ref.div;

module.exports = recl({
  displayName: "Load",
  getInitialState: function() {
    return {
      anim: 0
    };
  },
  componentDidMount: function() {
    return this.interval = setInterval(this.setAnim, 100);
  },
  componentWillUnmount: function() {
    return clearInterval(this.interval);
  },
  setAnim: function() {
    var anim;
    anim = this.state.anim + 1;
    if (anim > 3) {
      anim = 0;
    }
    return this.setState({
      anim: anim
    });
  },
  render: function() {
    return span({
      className: "loading state-" + this.state.anim
    }, '');
  }
});


},{}],12:[function(require,module,exports){
var TreeActions, div, recl;

recl = React.createClass;

div = React.DOM.div;

TreeActions = require('../actions/TreeActions.coffee');

module.exports = recl({
  displayName: "Module",
  componentDidMount: function() {
    return setTimeout((function(_this) {
      return function() {
        return TreeActions.setNav({
          title: _this.props["nav:title"],
          dpad: _this.props["nav:no-dpad"] != null ? false : void 0,
          sibs: _this.props["nav:no-sibs"] != null ? false : void 0,
          subnav: _this.props["nav:subnav"]
        }, 0);
      };
    })(this));
  },
  componentWillUnmount: function() {
    return TreeActions.clearNav();
  },
  render: function() {
    return div({
      className: "module"
    }, this.props.children);
  }
});


},{"../actions/TreeActions.coffee":1}],13:[function(require,module,exports){
var BodyComponent, Dpad, Nav, Sibs, TreeActions, TreeStore, a, button, clas, div, li, query, reactify, recl, ref, rend, ul, util;

clas = require('classnames');

BodyComponent = React.createFactory(require('./BodyComponent.coffee'));

query = require('./Async.coffee');

reactify = require('./Reactify.coffee');

TreeStore = require('../stores/TreeStore.coffee');

TreeActions = require('../actions/TreeActions.coffee');

Sibs = React.createFactory(require('./SibsComponent.coffee'));

Dpad = React.createFactory(require('./DpadComponent.coffee'));

util = require('../utils/util.coffee');

recl = React.createClass;

rend = ReactDOM.render;

ref = React.DOM, div = ref.div, a = ref.a, ul = ref.ul, li = ref.li, button = ref.button;

Nav = React.createFactory(query({
  path: 't',
  kids: {
    name: 't',
    head: 'r',
    meta: 'j'
  }
}, recl({
  displayName: "Links",
  stateFromStore: function() {
    return TreeStore.getNav();
  },
  getInitialState: function() {
    return this.stateFromStore();
  },
  _onChangeStore: function() {
    if (this.isMounted()) {
      return this.setState(this.stateFromStore());
    }
  },
  componentDidMount: function() {
    return TreeStore.addChangeListener(this._onChangeStore);
  },
  componentWillUnmount: function() {
    return TreeStore.removeChangeListener(this._onChangeStore);
  },
  onClick: function() {
    return this.toggleFocus();
  },
  onMouseOver: function() {
    return this.toggleFocus(true);
  },
  onMouseOut: function() {
    return this.toggleFocus(false);
  },
  onTouchStart: function() {
    return this.ts = Number(Date.now());
  },
  onTouchEnd: function() {
    var dt;
    return dt = this.ts - Number(Date.now());
  },
  _home: function() {
    return this.props.goTo(this.props.meta.navhome ? this.props.meta.navhome : "/");
  },
  toggleFocus: function(state) {
    return $(ReactDOM.findDOMNode(this)).toggleClass('focus', state);
  },
  toggleNav: function() {
    return TreeActions.toggleNav();
  },
  closeNav: function() {
    return TreeActions.closeNav();
  },
  render: function() {
    var attr, dpad, i, iconClass, itemsClass, len, linksClas, navClas, ref1, ref2, ref3, sibs, sub, subprops, title, toggleClas, v;
    attr = {
      onMouseOver: this.onMouseOver,
      onMouseOut: this.onMouseOut,
      onClick: this.onClick,
      onTouchStart: this.onTouchStart,
      onTouchEnd: this.onTouchEnd,
      'data-path': this.props.dataPath
    };
    if (_.keys(window).indexOf("ontouchstart") !== -1) {
      delete attr.onMouseOver;
      delete attr.onMouseOut;
    }
    linksClas = clas({
      links: true,
      subnav: (this.props.meta.navsub != null)
    });
    navClas = {
      navbar: this.props.meta.navmode === 'navbar',
      ctrl: true,
      open: this.state.open === true
    };
    if (this.props.meta.layout) {
      ref1 = this.props.meta.layout.split(",");
      for (i = 0, len = ref1.length; i < len; i++) {
        v = ref1[i];
        navClas[v.trim()] = true;
      }
    }
    navClas = clas(navClas);
    iconClass = clas({
      icon: true,
      'col-md-1': this.props.meta.navmode === 'navbar'
    });
    attr = _.extend(attr, {
      className: navClas,
      key: "nav"
    });
    title = this.state.title ? this.state.title : "";
    dpad = this.state.dpad !== false && ((ref2 = this.props.meta) != null ? ref2.navdpad : void 0) !== "false" ? Dpad(this.props, "") : "";
    sibs = this.state.sibs !== false && ((ref3 = this.props.meta) != null ? ref3.navsibs : void 0) !== "false" ? Sibs(_.merge(_.clone(this.props), {
      closeNav: this.closeNav
    }), "") : "";
    itemsClass = clas({
      items: true,
      'col-md-11': this.props.meta.navmode === 'navbar'
    });
    if (this.props.meta.navsub) {
      subprops = _.cloneDeep(this.props);
      subprops.dataPath = subprops.meta.navsub;
      delete subprops.meta.navselect;
      subprops.className = 'subnav';
      sub = Sibs(_.merge(subprops, {
        toggleNav: this.toggleNav
      }), "");
    }
    toggleClas = clas({
      'navbar-toggler': true,
      show: this.state.subnav != null
    });
    return div(attr, div({
      className: linksClas,
      key: "links"
    }, div({
      className: iconClass
    }, div({
      className: 'home',
      onClick: this._home
    }, ""), div({
      className: 'app'
    }, title), dpad, button({
      className: toggleClas,
      type: 'button',
      onClick: this.toggleNav
    }, "☰")), div({
      className: itemsClass
    }, sibs, sub)));
  }
}), recl({
  displayName: "Links_loading",
  _home: function() {
    return this.props.goTo("/");
  },
  render: function() {
    return div({
      className: "ctrl",
      "data-path": this.props.dataPath,
      key: "nav-loading"
    }, div({
      className: 'links'
    }, div({
      className: 'icon'
    }, div({
      className: 'home',
      onClick: this._home
    }, "")), ul({
      className: "nav"
    }, li({
      className: "nav-item selected"
    }, a({
      className: "nav-link"
    }, this.props.curr)))));
  }
})));

module.exports = query({
  sein: 't',
  path: 't',
  name: 't',
  meta: 'j'
}, recl({
  displayName: "Nav",
  stateFromStore: function() {
    return TreeStore.getNav();
  },
  getInitialState: function() {
    return _.extend(this.stateFromStore(), {
      url: window.location.pathname
    });
  },
  _onChangeStore: function() {
    if (this.isMounted()) {
      return this.setState(this.stateFromStore());
    }
  },
  componentWillUnmount: function() {
    clearInterval(this.interval);
    $('body').off('click', 'a');
    return TreeStore.removeChangeListener(this._onChangeStore);
  },
  componentDidUpdate: function() {
    this.setTitle();
    return this.checkRedirect();
  },
  componentDidMount: function() {
    var _this;
    this.setTitle();
    window.onpopstate = this.pullPath;
    TreeStore.addChangeListener(this._onChangeStore);
    _this = this;
    $('body').on('click', 'a', function(e) {
      var href, url;
      href = $(this).attr('href');
      if (href[0] === "#") {
        return true;
      }
      if (href && !/^https?:\/\//i.test(href)) {
        e.preventDefault();
        url = new URL(this.href);
        if (urb.util.basepath("", url.pathname) !== urb.util.basepath("", document.location.pathname)) {
          document.location = this.href;
          return;
        }
        if (url.pathname.substr(-1) !== "/") {
          url.pathname += "/";
        }
        return _this.goTo(url.pathname + url.search + url.hash);
      }
    });
    return this.checkRedirect();
  },
  checkRedirect: function() {
    if (this.props.meta.redirect) {
      return setTimeout(((function(_this) {
        return function() {
          return _this.goTo(_this.props.meta.redirect);
        };
      })(this)), 0);
    }
  },
  setTitle: function() {
    var path, ref1, title;
    title = $('#body h1').first().text() || this.props.name;
    if ((ref1 = this.props.meta) != null ? ref1.title : void 0) {
      title = this.props.meta.title;
    }
    path = this.props.path;
    if (path === "") {
      path = "/";
    }
    return document.title = title + " - " + path;
  },
  pullPath: function() {
    var l, path;
    l = document.location;
    path = l.pathname + l.search + l.hash;
    return this.setPath(path, false);
  },
  setPath: function(path, hist) {
    var next;
    if (hist !== false) {
      history.pushState({}, "", path);
    }
    next = util.fragpath(path.split('#')[0]);
    if (next !== this.props.path) {
      return TreeActions.setCurr(next);
    }
  },
  reset: function() {
    return $("html,body").animate({
      scrollTop: 0
    });
  },
  goTo: function(path) {
    this.reset();
    return this.setPath(path);
  },
  render: function() {
    var kids, kidsPath, navClas;
    if (this.props.meta.anchor === 'none') {
      return div({}, "");
    }
    navClas = clas({
      container: this.props.meta.container === 'false'
    });
    kidsPath = this.props.sein;
    if (this.props.meta.navpath) {
      kidsPath = this.props.meta.navpath;
    }
    kids = [
      Nav({
        curr: this.props.name,
        dataPath: kidsPath,
        meta: this.props.meta,
        sein: this.props.sein,
        goTo: this.goTo,
        key: "nav"
      }, "div")
    ];
    if (this.state.subnav) {
      kids.push(reactify({
        gn: this.state.subnav,
        ga: {
          open: this.state.open,
          toggle: TreeActions.toggleNav
        },
        c: []
      }, "subnav"));
    }
    return div({
      id: 'head',
      className: navClas
    }, kids);
  }
}));


},{"../actions/TreeActions.coffee":1,"../stores/TreeStore.coffee":25,"../utils/util.coffee":27,"./Async.coffee":2,"./BodyComponent.coffee":3,"./DpadComponent.coffee":7,"./Reactify.coffee":16,"./SibsComponent.coffee":19,"classnames":28}],14:[function(require,module,exports){
var a, li, nav, recl, ref, rele, ul;

recl = React.createClass;

rele = React.createElement;

ref = React.DOM, nav = ref.nav, ul = ref.ul, li = ref.li, a = ref.a;

module.exports = recl({
  render: function() {
    if (urb.user !== urb.ship) {
      return nav({
        className: "navbar panel"
      }, [
        ul({
          className: "nav navbar-nav"
        }, [
          li({
            className: 'nav-item pull-right'
          }, a({
            href: "/~~"
          }, "Log in"))
        ])
      ]);
    } else {
      return nav({
        className: "navbar panel"
      }, [
        ul({
          className: "nav navbar-nav"
        }, [
          li({
            className: "nav-item"
          }, a({
            href: "/~~/talk"
          }, "Talk")), li({
            className: "nav-item"
          }, a({
            href: "/~~/dojo"
          }, "Dojo")), li({
            className: "nav-item"
          }, a({
            href: "/~~/static"
          }, "Static")), li({
            className: 'nav-item pull-right'
          }, a({
            href: "/~/away"
          }, "Log out"))
        ])
      ]);
    }
  }
});


},{}],15:[function(require,module,exports){
var Grid, TreeActions, a, button, code, div, h6, input, load, query, recl, ref1, ref2, rele, span, table, tbody, td, textarea, tr,
  slice = [].slice;

load = require('./LoadComponent.coffee');

query = require('./Async.coffee');

TreeActions = require('../actions/TreeActions.coffee');

recl = React.createClass;

rele = React.createElement;

ref1 = React.DOM, div = ref1.div, textarea = ref1.textarea, button = ref1.button, input = ref1.input, a = ref1.a, h6 = ref1.h6, code = ref1.code, span = ref1.span;

ref2 = React.DOM, table = ref2.table, tbody = ref2.tbody, tr = ref2.tr, td = ref2.td;

Grid = function() {
  var _td, _tr, props, rows;
  props = arguments[0], rows = 2 <= arguments.length ? slice.call(arguments, 1) : [];
  _td = function(x) {
    return div({
      className: "td"
    }, x);
  };
  _tr = function(x) {
    if (x != null) {
      return div.apply(null, [{
        className: "tr"
      }].concat(slice.call(x.map(_td))));
    }
  };
  return div.apply(null, [props].concat(slice.call(rows.map(_tr))));
};

module.exports = query({
  plan: 'j',
  beak: 't',
  path: 't'
}, recl({
  displayName: "Plan",
  getInitialState: function() {
    return {
      edit: false,
      plan: this.props.plan,
      focus: null
    };
  },
  componentWillReceiveProps: function(props) {
    if (_.isEqual(this.props.plan, this.state.plan)) {
      return this.setState({
        plan: props.plan
      });
    }
  },
  refInput: function(ref) {
    return (function(_this) {
      return function(node) {
        _this[ref] = node;
        if (ref === _this.state.focus) {
          return node != null ? node.focus() : void 0;
        }
      };
    })(this);
  },
  saveInfo: function() {
    var plan, ref3;
    plan = {
      who: this.who.value,
      loc: this.loc.value,
      acc: (ref3 = this.props.plan) != null ? ref3.acc : void 0
    };
    if (!_.isEqual(plan, this.state.plan)) {
      TreeActions.setPlanInfo(plan);
      this.setState({
        plan: plan
      });
    }
    return this.setState({
      edit: false,
      focus: null
    });
  },
  render: function() {
    var acc, beak, editButton, editable, issuedBy, key, loc, path, ref3, ref4, ref5, url, usr, who;
    ref3 = this.props, beak = ref3.beak, path = ref3.path;
    ref5 = (ref4 = this.state.plan) != null ? ref4 : {}, acc = ref5.acc, loc = ref5.loc, who = ref5.who;
    issuedBy = urb.sein !== urb.ship ? "~" + urb.sein : "self";
    if (urb.user !== urb.ship) {
      editButton = null;
      editable = function(ref, val, placeholder) {
        return val != null ? val : placeholder;
      };
    } else if (this.state.edit) {
      editButton = button({
        className: 'edit',
        onClick: (function(_this) {
          return function() {
            return _this.saveInfo();
          };
        })(this)
      }, "Save");
      editable = (function(_this) {
        return function(ref, val, placeholder) {
          return input({
            placeholder: placeholder,
            defaultValue: val,
            ref: _this.refInput(ref),
            onKeyDown: function(arg) {
              var keyCode;
              keyCode = arg.keyCode;
              if (keyCode === 13) {
                return _this.saveInfo();
              }
            }
          });
        };
      })(this);
    } else {
      editButton = button({
        className: 'edit',
        onClick: (function(_this) {
          return function() {
            return _this.setState({
              edit: true
            });
          };
        })(this)
      }, "Edit");
      editable = (function(_this) {
        return function(ref, val, placeholder) {
          var ref6, ref7;
          return span({
            onClick: function() {
              return _this.setState({
                edit: true,
                focus: ref
              });
            }
          }, val != null ? val : placeholder, ((ref6 = _this.props.plan) != null ? ref6[ref] : void 0) !== ((ref7 = _this.state.plan) != null ? ref7[ref] : void 0) ? rele(load, {}) : void 0);
        };
      })(this);
    }
    return div({
      className: "plan"
    }, div({
      className: "home"
    }, ""), div({
      className: "mono"
    }, "~" + urb.ship), (who != null) || this.state.edit ? h6({}, editable('who', who, "Sun Tzu")) : void 0, Grid({
      className: "grid"
    }, ["Location:", editable('loc', loc, "Unknown")], ["Issued by:", issuedBy], [
      "Immutable link:", a({
        href: beak + "/web" + path
      }, beak)
    ], !_.isEmpty(acc) ? [
      "Connected to:", div({}, (function() {
        var ref6, results;
        results = [];
        for (key in acc) {
          ref6 = acc[key], usr = ref6.usr, url = ref6.url;
          results.push(div({
            key: key,
            className: 'service'
          }, url == null ? key + "/" + usr : a({
            href: url
          }, key + "/" + usr)));
        }
        return results;
      })())
    ] : void 0), editButton);
  }
}));


},{"../actions/TreeActions.coffee":1,"./Async.coffee":2,"./LoadComponent.coffee":11}],16:[function(require,module,exports){
var TreeStore, Virtual, div, load, reactify, recl, ref, rele, span, walk;

recl = React.createClass;

rele = React.createElement;

ref = React.DOM, div = ref.div, span = ref.span;

load = React.createFactory(require('./LoadComponent.coffee'));

TreeStore = require('../stores/TreeStore.coffee');

walk = function(root, _nil, _str, _comp) {
  var _walk;
  _walk = function(elem, key) {
    var c, ga, gn, ref1;
    switch (false) {
      case !(elem == null):
        return _nil();
      case typeof elem !== "string":
        return _str(elem);
      case elem.gn == null:
        gn = elem.gn, ga = elem.ga, c = elem.c;
        c = (ref1 = c != null ? c.map(_walk) : void 0) != null ? ref1 : [];
        return _comp.call(elem, {
          gn: gn,
          ga: ga,
          c: c
        }, key);
      default:
        throw "Bad react-json " + (JSON.stringify(elem));
    }
  };
  return _walk(root);
};

Virtual = recl({
  displayName: "Virtual",
  getInitialState: function() {
    return this.stateFromStore();
  },
  stateFromStore: function() {
    return {
      components: TreeStore.getVirtualComponents()
    };
  },
  _onChangeStore: function() {
    if (this.isMounted()) {
      return this.setState(this.stateFromStore());
    }
  },
  componentDidMount: function() {
    return TreeStore.addChangeListener(this._onChangeStore);
  },
  componentWillUnmount: function() {
    return TreeStore.removeChangeListener(this._onChangeStore);
  },
  render: function() {
    var basePath, components;
    components = this.state.components;
    basePath = this.props.basePath;
    return walk(this.props.manx, function() {
      return load({}, "");
    }, function(str) {
      return str;
    }, function(arg, key) {
      var c, e, error, ga, gn, props, ref1;
      gn = arg.gn, ga = arg.ga, c = arg.c;
      props = {
        key: key
      };
      if (ga != null ? ga.style : void 0) {
        try {
          ga.style = eval("(" + ga.style + ")");
        } catch (error) {
          e = error;
          ga.style = ga.style;
        }
      }
      if (components[gn]) {
        props.basePath = basePath;
      }
      return rele((ref1 = components[gn]) != null ? ref1 : gn, _.extend(props, ga), c.length ? c : void 0);
    });
  }
});

reactify = function(manx, key, arg) {
  var basePath;
  basePath = (arg != null ? arg : {}).basePath;
  return rele(Virtual, {
    manx: manx,
    key: key,
    basePath: basePath
  });
};

module.exports = _.extend(reactify, {
  walk: walk,
  Virtual: Virtual
});


},{"../stores/TreeStore.coffee":25,"./LoadComponent.coffee":11}],17:[function(require,module,exports){
var appendNext, recl, rele, waitingScripts;

recl = React.createClass;

rele = React.createElement;

waitingScripts = null;

appendNext = function() {
  if (waitingScripts == null) {
    return;
  }
  if (waitingScripts.length === 0) {
    return waitingScripts = null;
  } else {
    return document.body.appendChild(waitingScripts.shift());
  }
};

module.exports = recl({
  displayName: "Script",
  componentDidMount: function() {
    var s;
    s = document.createElement('script');
    _.assign(s, this.props);
    urb.waspElem(s);
    s.onload = appendNext;
    this.js = s;
    if (waitingScripts != null) {
      return waitingScripts.push(s);
    } else {
      waitingScripts = [s];
      return appendNext();
    }
  },
  componentWillUnmount: function() {
    if (this.js.parentNode === document.body) {
      return document.body.removeChild(this.js);
    }
  },
  render: function() {
    return rele("script", this.props);
  }
});


},{}],18:[function(require,module,exports){
var a, div, input, query, reactify, recl, ref,
  slice = [].slice;

query = require('./Async.coffee');

reactify = require('./Reactify.coffee');

recl = React.createClass;

ref = React.DOM, a = ref.a, div = ref.div, input = ref.input;

module.exports = query({
  name: 't',
  kids: {
    sect: 'j'
  }
}, recl({
  hash: null,
  displayName: "Search",
  getInitialState: function() {
    return {
      search: 'wut'
    };
  },
  onKeyUp: function(e) {
    return this.setState({
      search: e.target.value
    });
  },
  wrap: function(elem, dir, path) {
    var c, ga, gn, href, ref1;
    if (path.slice(-1) === "/") {
      path = path.slice(0, -1);
    }
    href = this.props.name + "/" + dir + path;
    if (elem != null ? (ref1 = elem.ga) != null ? ref1.id : void 0 : void 0) {
      gn = elem.gn, ga = elem.ga, c = elem.c;
      ga = _.clone(ga);
      href += "#" + ga.id;
      delete ga.id;
      elem = {
        gn: gn,
        ga: ga,
        c: c
      };
    }
    return {
      gn: 'div',
      c: [
        {
          gn: 'a',
          ga: {
            href: href
          },
          c: [elem]
        }
      ]
    };
  },
  render: function() {
    return div({}, input({
      onKeyUp: this.onKeyUp,
      ref: 'inp',
      defaultValue: 'wut'
    }), _(this.props.kids).map((function(_this) {
      return function(arg, dir) {
        var h, heds, path, results, sect;
        sect = arg.sect;
        results = [];
        for (path in sect) {
          heds = sect[path];
          results.push((function() {
            var i, len, results1;
            results1 = [];
            for (i = 0, len = heds.length; i < len; i++) {
              h = heds[i];
              results1.push(this.wrap(h, dir, path));
            }
            return results1;
          }).call(_this));
        }
        return results;
      };
    })(this)).flatten().flatten().map(this.highlight).filter().take(50).map(reactify).value());
  },
  highlight: function(e) {
    var got, res;
    if (!this.state.search) {
      return e;
    }
    got = false;
    res = reactify.walk(e, function() {
      return null;
    }, (function(_this) {
      return function(s) {
        var lit, m;
        m = s.split(_this.state.search);
        if (m[1] == null) {
          return [s];
        }
        lit = {
          gn: 'span',
          c: [_this.state.search],
          ga: {
            style: {
              background: '#ff6'
            }
          }
        };
        got = true;
        return [m[0]].concat(slice.call(_.flatten((function() {
            var i, len, ref1, results;
            ref1 = m.slice(1);
            results = [];
            for (i = 0, len = ref1.length; i < len; i++) {
              s = ref1[i];
              results.push([lit, s]);
            }
            return results;
          })())));
      };
    })(this), function(arg) {
      var c, ga, gn;
      gn = arg.gn, ga = arg.ga, c = arg.c;
      return {
        gn: gn,
        ga: ga,
        c: _.flatten(c)
      };
    });
    if (got) {
      return res;
    }
  }
}));


},{"./Async.coffee":2,"./Reactify.coffee":16}],19:[function(require,module,exports){
var a, clas, li, query, reactify, recl, ref, ul, util;

util = require('../utils/util.coffee');

clas = require('classnames');

reactify = require('./Reactify.coffee');

query = require('./Async.coffee');

recl = React.createClass;

ref = React.DOM, ul = ref.ul, li = ref.li, a = ref.a;

module.exports = query({
  path: 't',
  kids: {
    head: 'r',
    meta: 'j'
  }
}, recl({
  displayName: "Siblings",
  toText: function(elem) {
    return reactify.walk(elem, function() {
      return '';
    }, function(s) {
      return s;
    }, function(arg) {
      var c;
      c = arg.c;
      return (c != null ? c : []).join('');
    });
  },
  render: function() {
    var keys, navClas;
    keys = util.getKeys(this.props.kids);
    navClas = {
      nav: true,
      'col-md-12': this.props.meta.navmode === 'navbar'
    };
    if (this.props.className) {
      navClas[this.props.className] = true;
    }
    navClas = clas(navClas);
    return ul({
      className: navClas
    }, keys.map((function(_this) {
      return function(key) {
        var className, data, head, href, selected;
        selected = key === _this.props.curr;
        if (_this.props.meta.navselect) {
          selected = key === _this.props.meta.navselect;
        }
        href = util.basepath(_this.props.path + "/" + key);
        data = _this.props.kids[key];
        if (data.meta) {
          head = data.meta.title;
        }
        if (head == null) {
          head = _this.toText(data.head);
        }
        head || (head = key);
        className = clas({
          "nav-item": true,
          selected: selected
        });
        if (data.meta.sibsclass) {
          className += " " + clas(data.meta.sibsclass.split(","));
        }
        return li({
          className: className,
          key: key
        }, a({
          className: "nav-link",
          href: href,
          onClick: _this.props.closeNav
        }, head));
      };
    })(this)));
  }
}));


},{"../utils/util.coffee":27,"./Async.coffee":2,"./Reactify.coffee":16,"classnames":28}],20:[function(require,module,exports){
var div, query, reactify, recl,
  slice = [].slice;

query = require('./Async.coffee');

reactify = require('./Reactify.coffee');

recl = React.createClass;

div = React.DOM.div;

module.exports = query({
  body: 'r'
}, recl({
  hash: null,
  displayName: "TableOfContents",
  _click: function(id) {
    return function() {
      if (id) {
        return document.location.hash = id;
      }
    };
  },
  componentDidMount: function() {
    this.int = setInterval(this.checkHash, 100);
    this.st = $(window).scrollTop();
    return this.$headers = $('#toc').children('h1,h2,h3,h4').filter('[id]');
  },
  checkScroll: function() {
    var $h, hash, hst, i, len, ref, results, st, v;
    st = $(window).scrollTop();
    if (Math.abs(this.st - st) > 10) {
      hash = null;
      this.st = st;
      ref = this.$headers;
      results = [];
      for (i = 0, len = ref.length; i < len; i++) {
        v = ref[i];
        if (v.tagName === void 0) {
          continue;
        }
        $h = $(v);
        hst = $h.offset().top - $h.outerHeight(true) + 10;
        if (hst < st) {
          hash = $h.attr('id');
        }
        if (hst > st && hash !== this.hash && hash !== null) {
          this.hash = "#" + hash;
          document.location.hash = hash;
          break;
        } else {
          results.push(void 0);
        }
      }
      return results;
    }
  },
  checkHash: function() {
    var $h, hash, i, len, offset, ref, ref1, results, v;
    if (((ref = document.location.hash) != null ? ref.length : void 0) > 0 && document.location.hash !== this.hash) {
      hash = document.location.hash.slice(1);
      ref1 = this.$headers;
      results = [];
      for (i = 0, len = ref1.length; i < len; i++) {
        v = ref1[i];
        $h = $(v);
        if (hash === $h.attr('id')) {
          this.hash = document.location.hash;
          offset = $h.offset().top - $h.outerHeight(true);
          setTimeout(function() {
            return $(window).scrollTop(offset, 10);
          });
          break;
        } else {
          results.push(void 0);
        }
      }
      return results;
    }
  },
  componentWillUnmount: function() {
    return clearInterval(this.int);
  },
  collectHeader: function(arg) {
    var c, comp, ga, gn;
    gn = arg.gn, ga = arg.ga, c = arg.c;
    if (this.props.match) {
      comp = gn === this.props.match;
    } else {
      comp = gn && gn[0] === 'h' && parseInt(gn[1]) !== NaN;
    }
    if (comp) {
      ga = _.clone(ga);
      ga.onClick = this._click(ga.id);
      delete ga.id;
      return {
        gn: gn,
        ga: ga,
        c: c
      };
    }
  },
  parseHeaders: function() {
    var contents, i, len, ref, ref1, v;
    if (this.props.body.c) {
      ref = this.props.body.c;
      for (i = 0, len = ref.length; i < len; i++) {
        v = ref[i];
        if (v.gn === 'div' && ((ref1 = v.ga) != null ? ref1.id : void 0) === "toc") {
          contents = [{
              gn: "h1",
              ga: {
                className: "t"
              },
              c: ["Table of contents"]
            }].concat(slice.call(_.filter(v.c.map(this.collectHeader))));
          if (this.props.noHeader) {
            contents.shift();
          }
          return {
            gn: "div",
            ga: {
              className: "toc"
            },
            c: contents
          };
        }
      }
    }
  },
  render: function() {
    return reactify(this.parseHeaders());
  }
}));


},{"./Async.coffee":2,"./Reactify.coffee":16}],21:[function(require,module,exports){
var body, clas, div, head, query, recf, recl;

query = require('./Async.coffee');

clas = require('classnames');

recf = React.createFactory;

recl = React.createClass;

head = recf(require('./NavComponent.coffee'));

body = recf(require('./BodyComponent.coffee'));

div = React.DOM.div;

module.exports = query({
  body: 'r',
  name: 't',
  path: 't',
  meta: 'j',
  sein: 't'
}, recl({
  displayName: "Tree",
  render: function() {
    var treeClas;
    treeClas = clas({
      container: this.props.meta.container !== 'false'
    });
    return div({
      className: treeClas
    }, [
      head({
        key: 'head-container'
      }, ""), body({
        key: 'body-container'
      }, "")
    ]);
  }
}));


},{"./Async.coffee":2,"./BodyComponent.coffee":3,"./NavComponent.coffee":13,"classnames":28}],22:[function(require,module,exports){
module.exports = _.extend(new Flux.Dispatcher(), {
  handleServerAction: function(action) {
    return this.dispatch({
      source: 'server',
      action: action
    });
  },
  handleViewAction: function(action) {
    return this.dispatch({
      source: 'view',
      action: action
    });
  }
});


},{}],23:[function(require,module,exports){
var rend;

rend = ReactDOM.render;

$(function() {
  var frag, main, util;
  util = require('./utils/util.coffee');
  require('./utils/scroll.coffee');
  if (document.location.pathname.substr(-1) !== "/") {
    history.replaceState({}, "", document.location.pathname + "/" + document.location.search + document.location.hash);
  }
  window.tree.actions = require('./actions/TreeActions.coffee');
  window.tree.actions.addVirtual(require('./components/Components.coffee'));
  frag = util.fragpath(window.location.pathname.replace(/\.[^\/]*$/, ''));
  window.tree.actions.setCurr(frag);
  window.tree.actions.loadPath(frag, window.tree.data);
  if (window.tree.sein != null) {
    window.tree.actions.loadSein(frag, window.tree.sein);
  }
  window.urb.ondataupdate = function(dep) {
    var dat;
    for (dat in window.urb.datadeps) {
      window.urb.dewasp(dat);
    }
    return window.tree.actions.clearData();
  };
  main = React.createFactory(require('./components/TreeComponent.coffee'));
  return rend(main({}, ""), document.getElementById('tree'));
});


},{"./actions/TreeActions.coffee":1,"./components/Components.coffee":6,"./components/TreeComponent.coffee":21,"./utils/scroll.coffee":26,"./utils/util.coffee":27}],24:[function(require,module,exports){
var dedup, pending, util, waspWait;

util = require('../utils/util.coffee');

dedup = {};

pending = {};

waspWait = [];

module.exports = {
  refresh: function() {
    return dedup = {};
  },
  get: function(path, query, cb) {
    var url;
    if (query == null) {
      query = "no-query";
    }
    url = (util.basepath(path)) + ".tree-json?q=" + (this.encode(query));
    if (dedup[url]) {
      return;
    }
    dedup[url] = true;
    pending[url] = true;
    return $.get(url, {}, function(data, status, xhr) {
      var dep;
      delete pending[url];
      dep = urb.getXHRWasp(xhr);
      urb.sources[dep] = url;
      waspWait.push(dep);
      if (_.isEmpty(pending)) {
        waspWait.map(urb.waspData);
        waspWait = [];
      }
      if (cb) {
        return cb(null, data);
      }
    });
  },
  put: function(data, mark, appl) {
    if (appl == null) {
      appl = /[a-z]*/.exec(mark)[0];
    }
    return urb.send(data, {
      mark: mark,
      appl: appl
    });
  },
  encode: function(obj) {
    var _encode, delim;
    delim = function(n) {
      return Array(n + 1).join('_') || '.';
    };
    _encode = function(obj) {
      var _dep, dep, k, res, sub, v;
      if (typeof obj !== 'object') {
        return [0, obj];
      }
      dep = 0;
      sub = (function() {
        var ref, results;
        results = [];
        for (k in obj) {
          v = obj[k];
          ref = _encode(v), _dep = ref[0], res = ref[1];
          if (_dep > dep) {
            dep = _dep;
          }
          if (res != null) {
            results.push(k + (delim(_dep)) + res);
          } else {
            results.push(void 0);
          }
        }
        return results;
      })();
      dep++;
      return [dep, sub.join(delim(dep))];
    };
    return (_encode(obj))[1];
  }
};


},{"../utils/util.coffee":27}],25:[function(require,module,exports){
var EventEmitter, MessageDispatcher, QUERIES, TreeStore, _curr, _data, _nav, _tree, _virt, clog;

EventEmitter = require('events').EventEmitter.EventEmitter;

MessageDispatcher = require('../dispatcher/Dispatcher.coffee');

clog = console.log.bind(console);

_virt = {};

_tree = {};

_data = {};

_curr = "";

_nav = {};

QUERIES = {
  body: 'r',
  head: 'r',
  snip: 'r',
  sect: 'j',
  meta: 'j',
  comt: 'j',
  plan: 'j',
  beak: 't'
};

TreeStore = _.extend((new EventEmitter).setMaxListeners(50), {
  addChangeListener: function(cb) {
    return this.on('change', cb);
  },
  removeChangeListener: function(cb) {
    return this.removeListener("change", cb);
  },
  emitChange: function() {
    return this.emit('change');
  },
  pathToArr: function(_path) {
    return _path.split("/");
  },
  fulfill: function(path, query) {
    if (path === "/") {
      path = "";
    }
    return this.fulfillAt(this.getTree(path.split('/')), path, query);
  },
  fulfillAt: function(tree, path, query) {
    var data, have, k, sub, t;
    data = this.fulfillLocal(path, query);
    have = _data[path];
    if (have != null) {
      for (k in query) {
        t = query[k];
        if (!QUERIES[k]) {
          continue;
        }
        if (t !== QUERIES[k]) {
          throw TypeError("Wrong query type: " + k + ", '" + t + "'");
        }
        data[k] = have[k];
      }
    }
    if (query.kids) {
      if ((have != null ? have.kids : void 0) === false) {
        data.kids = {};
      } else {
        for (k in tree) {
          sub = tree[k];
          if (data.kids == null) {
            data.kids = {};
          }
          data.kids[k] = this.fulfillAt(sub, path + "/" + k, query.kids);
        }
      }
    }
    if (!_.isEmpty(data)) {
      return data;
    }
  },
  fulfillLocal: function(path, query) {
    var data;
    data = {};
    if (query.path) {
      data.path = path;
    }
    if (query.name) {
      data.name = path.split("/").pop();
    }
    if (query.sein) {
      data.sein = this.getPare(path);
    }
    if (query.next) {
      data.next = this.getNext(path);
    }
    if (query.prev) {
      data.prev = this.getPrev(path);
    }
    return data;
  },
  setCurr: function(arg) {
    var path;
    path = arg.path;
    return _curr = path;
  },
  getCurr: function() {
    return _curr;
  },
  addVirtual: function(arg) {
    var components;
    components = arg.components;
    return _.extend(_virt, components);
  },
  getVirtualComponents: function() {
    return _virt;
  },
  clearData: function() {
    _data = {};
    return _tree = {};
  },
  loadSein: function(arg) {
    var data, path, sein;
    path = arg.path, data = arg.data;
    sein = this.getPare(path);
    if (sein != null) {
      return this.loadPath({
        path: sein,
        data: data
      });
    }
  },
  loadPath: function(arg) {
    var data, path;
    path = arg.path, data = arg.data;
    return this.loadValues(this.getTree(path.split('/'), true), path, data);
  },
  loadValues: function(tree, path, data) {
    var _path, k, old, ref, ref1, v;
    old = (ref = _data[path]) != null ? ref : {};
    for (k in data) {
      if (QUERIES[k]) {
        old[k] = data[k];
      }
    }
    ref1 = data.kids;
    for (k in ref1) {
      v = ref1[k];
      if (tree[k] == null) {
        tree[k] = {};
      }
      _path = path;
      if (_path === "/") {
        _path = "";
      }
      this.loadValues(tree[k], _path + "/" + k, v);
    }
    if (data.kids && _.isEmpty(data.kids)) {
      old.kids = false;
    }
    return _data[path] = old;
  },
  getSiblings: function(path) {
    var curr;
    if (path == null) {
      path = _curr;
    }
    curr = path.split("/");
    curr.pop();
    if (curr.length !== 0) {
      return this.getTree(curr);
    } else {
      return {};
    }
  },
  getTree: function(_path, make) {
    var i, len, sub, tree;
    if (make == null) {
      make = false;
    }
    tree = _tree;
    for (i = 0, len = _path.length; i < len; i++) {
      sub = _path[i];
      if (!sub) {
        continue;
      }
      if (tree[sub] == null) {
        if (!make) {
          return null;
        }
        tree[sub] = {};
      }
      tree = tree[sub];
    }
    return tree;
  },
  getPrev: function(path) {
    var ind, key, par, sibs, win;
    if (path == null) {
      path = _curr;
    }
    sibs = _.keys(this.getSiblings(path)).sort();
    if (sibs.length < 2) {
      return null;
    } else {
      par = path.split("/");
      key = par.pop();
      ind = sibs.indexOf(key);
      win = ind - 1 >= 0 ? sibs[ind - 1] : sibs[sibs.length - 1];
      par.push(win);
      return par.join("/");
    }
  },
  getNext: function(path) {
    var ind, key, par, sibs, win;
    if (path == null) {
      path = _curr;
    }
    sibs = _.keys(this.getSiblings(path)).sort();
    if (sibs.length < 2) {
      return null;
    } else {
      par = path.split("/");
      key = par.pop();
      ind = sibs.indexOf(key);
      win = ind + 1 < sibs.length ? sibs[ind + 1] : sibs[0];
      par.push(win);
      return par.join("/");
    }
  },
  getPare: function(path) {
    var _path;
    if (path == null) {
      path = _curr;
    }
    _path = this.pathToArr(path);
    if (_path.length > 1) {
      _path.pop();
      _path = _path.join("/");
      if (_path === "") {
        _path = "/";
      }
      return _path;
    } else {
      return null;
    }
  },
  setNav: function(arg) {
    var dpad, nav, sibs, subnav, title;
    title = arg.title, dpad = arg.dpad, sibs = arg.sibs, subnav = arg.subnav;
    nav = {
      title: title,
      dpad: dpad,
      sibs: sibs,
      subnav: subnav,
      open: (_nav.open ? _nav.open : false)
    };
    return _nav = nav;
  },
  getNav: function() {
    return _nav;
  },
  toggleNav: function() {
    return _nav.open = !_nav.open;
  },
  closeNav: function() {
    return _nav.open = false;
  },
  clearNav: function() {
    return _nav = {
      title: null,
      dpad: null,
      sibs: null,
      subnav: null,
      open: false
    };
  }
});

TreeStore.dispatchToken = MessageDispatcher.register(function(p) {
  var a;
  a = p.action;
  if (TreeStore[a.type]) {
    TreeStore[a.type](a);
    return TreeStore.emitChange();
  }
});

module.exports = TreeStore;


},{"../dispatcher/Dispatcher.coffee":22,"events":29}],26:[function(require,module,exports){
var scroll;

scroll = {
  w: null,
  $d: null,
  $n: null,
  nh: null,
  cs: null,
  ls: null,
  track: function() {
    this.w = $(window).width();
    this.$n = $('#head');
    this.$d = $('#head .ctrl');
    return this.nh = $('#head .ctrl').outerHeight(true);
  },
  clearNav: function() {
    return this.$n.removeClass('m-up m-down m-fixed');
  },
  resize: function() {
    if (this.w > 1170) {
      return this.clearNav();
    }
  },
  scroll: function() {
    var ct, dy, top;
    this.cs = $(window).scrollTop();
    if (this.w > 767) {
      this.clearNav();
    }
    if (this.w < 767) {
      dy = this.ls - this.cs;
      this.$d.removeClass('focus');
      if (this.cs <= 0) {
        this.$n.removeClass('m-up');
        this.$n.addClass('m-down m-fixed');
        return;
      }
      if (dy > 0) {
        if (!this.$n.hasClass('m-down')) {
          this.$n.removeClass('m-up').addClass('m-down');
          ct = this.$n.offset().top;
          top = this.cs - this.nh;
          if (this.cs > ct && this.cs < ct + this.nh) {
            top = ct;
          }
          this.$n.offset({
            top: top
          });
        }
        if (this.$n.hasClass('m-down') && !this.$n.hasClass('m-fixed') && this.$n.offset().top >= this.cs) {
          this.$n.addClass('m-fixed');
          this.$n.attr({
            style: ''
          });
        }
      }
      if (dy < 0) {
        if (!this.$n.hasClass('m-up')) {
          this.$n.removeClass('m-down m-fixed').addClass('m-up');
          this.$d.removeClass('open');
          $('.menu.open').removeClass('open');
          top = this.cs < 0 ? 0 : this.cs;
          ct = this.$n.offset().top;
          if (top > ct && top < ct + this.nh) {
            top = ct;
          }
          this.$n.offset({
            top: top
          });
        }
        if (this.$n.hasClass('m-up') && this.$d.hasClass('open')) {
          if (this.cs > this.$n.offset().top + this.$n.height()) {
            this.$d.removeClass('open');
          }
        }
      }
    }
    return this.ls = this.cs;
  },
  init: function() {
    setInterval(this.track.bind(this), 200);
    this.ls = $(window).scrollTop();
    this.cs = $(window).scrollTop();
    $(window).on('resize', this.resize.bind(this));
    return $(window).on('scroll', this.scroll.bind(this));
  }
};

scroll.init();

module.exports = scroll;


},{}],27:[function(require,module,exports){
var _basepath;

_basepath = window.urb.util.basepath("/");

_basepath += (window.location.pathname.replace(window.tree._basepath, "")).split("/")[0];

module.exports = {
  basepath: function(path) {
    var _path, prefix;
    prefix = _basepath;
    if (prefix === "/") {
      prefix = "";
    }
    if (path[0] !== "/") {
      path = "/" + path;
    }
    _path = prefix + path;
    if (_path.slice(-1) === "/" && _path.length > 1) {
      _path = _path.slice(0, -1);
    }
    return _path;
  },
  fragpath: function(path) {
    return path.replace(/\/$/, '').replace(_basepath, "");
  },
  getKeys: function(kids) {
    var k, keys, ref, ref1, ref2, sorted, v;
    sorted = true;
    keys = [];
    for (k in kids) {
      v = kids[k];
      if ((ref = v.meta) != null ? ref.hide : void 0) {
        continue;
      }
      if (((ref1 = v.meta) != null ? ref1.sort : void 0) == null) {
        sorted = false;
      }
      keys[Number((ref2 = v.meta) != null ? ref2.sort : void 0)] = k;
    }
    if (sorted !== true) {
      return keys = _.keys(kids).sort();
    } else {
      return keys = _.values(keys);
    }
  }
};


},{}],28:[function(require,module,exports){
/*!
  Copyright (c) 2016 Jed Watson.
  Licensed under the MIT License (MIT), see
  http://jedwatson.github.io/classnames
*/
/* global define */

(function () {
	'use strict';

	var hasOwn = {}.hasOwnProperty;

	function classNames () {
		var classes = [];

		for (var i = 0; i < arguments.length; i++) {
			var arg = arguments[i];
			if (!arg) continue;

			var argType = typeof arg;

			if (argType === 'string' || argType === 'number') {
				classes.push(arg);
			} else if (Array.isArray(arg)) {
				classes.push(classNames.apply(null, arg));
			} else if (argType === 'object') {
				for (var key in arg) {
					if (hasOwn.call(arg, key) && arg[key]) {
						classes.push(key);
					}
				}
			}
		}

		return classes.join(' ');
	}

	if (typeof module !== 'undefined' && module.exports) {
		module.exports = classNames;
	} else if (typeof define === 'function' && typeof define.amd === 'object' && define.amd) {
		// register as 'classnames', consistent with npm package name
		define('classnames', [], function () {
			return classNames;
		});
	} else {
		window.classNames = classNames;
	}
}());

},{}],29:[function(require,module,exports){
// Copyright Joyent, Inc. and other Node contributors.
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to permit
// persons to whom the Software is furnished to do so, subject to the
// following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
// USE OR OTHER DEALINGS IN THE SOFTWARE.

function EventEmitter() {
  this._events = this._events || {};
  this._maxListeners = this._maxListeners || undefined;
}
module.exports = EventEmitter;

// Backwards-compat with node 0.10.x
EventEmitter.EventEmitter = EventEmitter;

EventEmitter.prototype._events = undefined;
EventEmitter.prototype._maxListeners = undefined;

// By default EventEmitters will print a warning if more than 10 listeners are
// added to it. This is a useful default which helps finding memory leaks.
EventEmitter.defaultMaxListeners = 10;

// Obviously not all Emitters should be limited to 10. This function allows
// that to be increased. Set to zero for unlimited.
EventEmitter.prototype.setMaxListeners = function(n) {
  if (!isNumber(n) || n < 0 || isNaN(n))
    throw TypeError('n must be a positive number');
  this._maxListeners = n;
  return this;
};

EventEmitter.prototype.emit = function(type) {
  var er, handler, len, args, i, listeners;

  if (!this._events)
    this._events = {};

  // If there is no 'error' event listener then throw.
  if (type === 'error') {
    if (!this._events.error ||
        (isObject(this._events.error) && !this._events.error.length)) {
      er = arguments[1];
      if (er instanceof Error) {
        throw er; // Unhandled 'error' event
      }
      throw TypeError('Uncaught, unspecified "error" event.');
    }
  }

  handler = this._events[type];

  if (isUndefined(handler))
    return false;

  if (isFunction(handler)) {
    switch (arguments.length) {
      // fast cases
      case 1:
        handler.call(this);
        break;
      case 2:
        handler.call(this, arguments[1]);
        break;
      case 3:
        handler.call(this, arguments[1], arguments[2]);
        break;
      // slower
      default:
        args = Array.prototype.slice.call(arguments, 1);
        handler.apply(this, args);
    }
  } else if (isObject(handler)) {
    args = Array.prototype.slice.call(arguments, 1);
    listeners = handler.slice();
    len = listeners.length;
    for (i = 0; i < len; i++)
      listeners[i].apply(this, args);
  }

  return true;
};

EventEmitter.prototype.addListener = function(type, listener) {
  var m;

  if (!isFunction(listener))
    throw TypeError('listener must be a function');

  if (!this._events)
    this._events = {};

  // To avoid recursion in the case that type === "newListener"! Before
  // adding it to the listeners, first emit "newListener".
  if (this._events.newListener)
    this.emit('newListener', type,
              isFunction(listener.listener) ?
              listener.listener : listener);

  if (!this._events[type])
    // Optimize the case of one listener. Don't need the extra array object.
    this._events[type] = listener;
  else if (isObject(this._events[type]))
    // If we've already got an array, just append.
    this._events[type].push(listener);
  else
    // Adding the second element, need to change to array.
    this._events[type] = [this._events[type], listener];

  // Check for listener leak
  if (isObject(this._events[type]) && !this._events[type].warned) {
    if (!isUndefined(this._maxListeners)) {
      m = this._maxListeners;
    } else {
      m = EventEmitter.defaultMaxListeners;
    }

    if (m && m > 0 && this._events[type].length > m) {
      this._events[type].warned = true;
      console.error('(node) warning: possible EventEmitter memory ' +
                    'leak detected. %d listeners added. ' +
                    'Use emitter.setMaxListeners() to increase limit.',
                    this._events[type].length);
      if (typeof console.trace === 'function') {
        // not supported in IE 10
        console.trace();
      }
    }
  }

  return this;
};

EventEmitter.prototype.on = EventEmitter.prototype.addListener;

EventEmitter.prototype.once = function(type, listener) {
  if (!isFunction(listener))
    throw TypeError('listener must be a function');

  var fired = false;

  function g() {
    this.removeListener(type, g);

    if (!fired) {
      fired = true;
      listener.apply(this, arguments);
    }
  }

  g.listener = listener;
  this.on(type, g);

  return this;
};

// emits a 'removeListener' event iff the listener was removed
EventEmitter.prototype.removeListener = function(type, listener) {
  var list, position, length, i;

  if (!isFunction(listener))
    throw TypeError('listener must be a function');

  if (!this._events || !this._events[type])
    return this;

  list = this._events[type];
  length = list.length;
  position = -1;

  if (list === listener ||
      (isFunction(list.listener) && list.listener === listener)) {
    delete this._events[type];
    if (this._events.removeListener)
      this.emit('removeListener', type, listener);

  } else if (isObject(list)) {
    for (i = length; i-- > 0;) {
      if (list[i] === listener ||
          (list[i].listener && list[i].listener === listener)) {
        position = i;
        break;
      }
    }

    if (position < 0)
      return this;

    if (list.length === 1) {
      list.length = 0;
      delete this._events[type];
    } else {
      list.splice(position, 1);
    }

    if (this._events.removeListener)
      this.emit('removeListener', type, listener);
  }

  return this;
};

EventEmitter.prototype.removeAllListeners = function(type) {
  var key, listeners;

  if (!this._events)
    return this;

  // not listening for removeListener, no need to emit
  if (!this._events.removeListener) {
    if (arguments.length === 0)
      this._events = {};
    else if (this._events[type])
      delete this._events[type];
    return this;
  }

  // emit removeListener for all listeners on all events
  if (arguments.length === 0) {
    for (key in this._events) {
      if (key === 'removeListener') continue;
      this.removeAllListeners(key);
    }
    this.removeAllListeners('removeListener');
    this._events = {};
    return this;
  }

  listeners = this._events[type];

  if (isFunction(listeners)) {
    this.removeListener(type, listeners);
  } else if (listeners) {
    // LIFO order
    while (listeners.length)
      this.removeListener(type, listeners[listeners.length - 1]);
  }
  delete this._events[type];

  return this;
};

EventEmitter.prototype.listeners = function(type) {
  var ret;
  if (!this._events || !this._events[type])
    ret = [];
  else if (isFunction(this._events[type]))
    ret = [this._events[type]];
  else
    ret = this._events[type].slice();
  return ret;
};

EventEmitter.prototype.listenerCount = function(type) {
  if (this._events) {
    var evlistener = this._events[type];

    if (isFunction(evlistener))
      return 1;
    else if (evlistener)
      return evlistener.length;
  }
  return 0;
};

EventEmitter.listenerCount = function(emitter, type) {
  return emitter.listenerCount(type);
};

function isFunction(arg) {
  return typeof arg === 'function';
}

function isNumber(arg) {
  return typeof arg === 'number';
}

function isObject(arg) {
  return typeof arg === 'object' && arg !== null;
}

function isUndefined(arg) {
  return arg === void 0;
}

},{}]},{},[23]);
window.urb = window.urb || {}
window.urb.appl = window.urb.appl || null

window.urb.req = function(method,url,params,json,cb) {
  var xhr = new XMLHttpRequest()
  method = method.toUpperCase()
  if(method == "PUT" || method == "DELETE")
    xhr.open("POST", url+"?"+method)
  else xhr.open(method, url)
  
  if(json)
    xhr.setRequestHeader("content-type", "text/json")

  if(!window.urb.oryx) throw "No CSRF token" // XX fetch auth.json
  _data = {oryx: window.urb.oryx}
  if(params.xyro) { _data.xyro = params.xyro; }
  if(params.ship) { _data.ship = params.ship; }
  if(params.path) { _data.path = params.path; }
  if(params.appl) { _data.appl = params.appl; }
  if(params.mark) { _data.mark = params.mark; }
  if(params.wire) { _data.wire = params.wire; }
  if(cb) {
    xhr.onload = function() {
      var err,res
      try {
        err = null
        res = {
          status:this.status,
          data: JSON.parse(this.responseText)
        }
        if(res.data.reload)
          res.reload = res.data.reload
      } catch(e) {
        // if(urb.wall !== false) document.write(this.responseText) // XX
        err = {
          message:"Failed to parse JSON",
          raw:this.responseText
        }
        res = null
      }
      finally {
       cb(err,res)
      }
    }
    xhr.onerror = function() {
      cb({
        status:this.status,
        data:this.responseText
      })
    }
  }
  xhr.send(JSON.stringify(_data))
}

// window.urb.getJSON = function(url,cb){ window.urb.reqJSON("GET",url, null, cb)}
// window.urb.reqJSON = function(method, url, data, cb){
//   var xhr = new XMLHttpRequest()
//   xhr.open(method, url)
//   xhr.onload = function(){
//     urb.fetchTag.call(xhr)
//     if(cb) cb(JSON.parse(xhr.responseText))
//   }
//   xhr.send(data === null ? null : JSON.stringify(data))
// }

window.urb.reqq = []
window.urb.qreq = function(method,url,params,json,cb) {
  walk = function() {
    qobj = {}
    qobj.oargs = window.urb.reqq[0]
    qobj.nargs = [].slice.call(qobj.oargs,0,4)
    qobj.nargs.push(function(){
      if(this.oargs[4])
        this.oargs[4].apply(window.urb,arguments)
      window.urb.reqq.shift()
      if(window.urb.reqq.length > 0)
        walk()
    }.bind(qobj))
    window.urb.req.apply(this,qobj.nargs)
  }
  l = window.urb.reqq.length
  window.urb.reqq.push(arguments);
  if(l == 0) { walk() }
}

window.urb.send = function(data,params,cb) { // or send(data, cb)
  if(!params || typeof params === "function")
    {cb = params; params = {}}

  var url, $send
  $send = this.send

  params.data = data
  params.ship = params.ship || this.ship
  params.appl = params.appl || this.appl
  params.mark = params.mark || $send.mark
  // params.seqn = params.seqn || $send.seqn
  params.wire = params.wire || "/"
  params.xyro = (typeof(params.data) === 'undefined') ? null : params.data

  
  if(!params.mark) throw new Error("You must specify a mark for urb.send.")
  if(!params.appl) throw new Error("You must specify an appl for urb.send.")

  url = ["to",params.appl,params.mark]
  url = "/~/"+url.join("/")

  // $send.seqn++

  this.qreq('post',url,params,true,function(err,data) {
    /* if(err) { $send.seqn--; }
    else */ if(data && data.data.fail && urb.wall !== false && params.wall !== false) {
      document.location = "#ERROR"
      document.write("<pre>"+JSON.stringify(params.xyro)+"\n"
                            +data.data.mess+"</pre>") // XX
    }
    if(cb) { cb.apply(this,arguments); }
  })
}
// window.urb.send.seqn = 0
window.urb.send.mark = "json"


window.urb.gsig = function(params) {
  var path = params.path
  if(!path) path = ""
  if(path[0] !== "/") path = "/"+path
  return  "~"+params.ship+"/"+
          params.appl+
          path.replace(/[^\x00-\x7F]/g, "")
}

window.urb.puls = false
window.urb.cabs = {}
window.urb.poll = function(params) {
  if(!params) throw new Error("You must supply params to urb.poll.")

  var url, $this

  seqn = this.poll.seqn
  if(params.seqn) seqn = params.seqn()
  
  url = "/~/of/"+this.ixor+"?poll="+seqn

  this.puls = true

  $this = this
  this.req("get",url,params,true,function(err,res) {
    $this.poll.dely = params.dely || $this.poll.dely
    if(res){
      if(res.data.beat)
        return $this.poll(params)
      switch(res.data.type){
          case "news":
        return document.location.reload()  // XX check autoreload
          case "rush":
          case "mean":
        var err2 = err
        if(res.data.type == "mean")
          err2 = res.data.data
        var fn = $this.gsig(res.data.from)
        if($this.cabs[fn])
          $this.cabs[fn].call(this,err2,
            {status: res.status, data: res.data.data.json}) // XX non-json
        break;
          case "quit":
        //  XX necessary behaviour?
        break;
          default:
        throw new Error("Lost event %"+res.data.type)
      }
      if(params.incs)
        params.incs()
      else 
        $this.poll.seqn++
      $this.poll.dely = 250
      return $this.poll(params)
    }
    
    else if(err){
      setTimeout(function() {
        $this.poll(params)
      }, $this.poll.dely)
      $this.poll.dely += Math.ceil($this.poll.dely*.2)
    }
    else throw "Neither error nor result on poll"
  })
}
window.urb.poll.seqn = 1
window.urb.poll.dely = 250

window.urb.bind = function(path, params, cb, nicecb){ // or bind(path, cb)
  if(!params || typeof params === "function")
    {cb = params; params = {}}
    
  params.path = path
  if(params.path[0] !== "/") params.path = "/"+params.path
  params.ship = params.ship || this.ship
  params.appl = params.appl || this.appl
  params.mark = params.mark || this.bind.mark
  params.wire = params.wire || params.path

  if(typeof path != "string")
    throw new Error("You must specify a string path for urb.bind.")
  if(!params.appl) throw new Error("You must specify an appl for urb.bind.")
  if(!cb) throw new Error("You must supply a callback to urb.bind.")
  
  var method, perm, url, $this

  if(params.mark !== "json")
    throw new Error("Non-json subscriptions unimplemented.")  //  XX
  url = "/~/is/"+this.gsig(params)+"."+params.mark
  
  params.path = params.wire
  this.cabs[this.gsig(params)] = cb

  $this = this
  this.qreq("put",url,params,true,function(err,res) {
    if(nicecb) { nicecb.apply(this,[err,{status: res.status, data: res.data}])}
    //  XX give raw data
    //
    if(!err && !$this.puls) $this.poll(params)
  })
}
urb.bind.mark = "json"

window.urb.drop = function(path, params, cb){  // or drop(path,cb)
  if(typeof params === "function")
    {cb = params; params = {}}
    
  params.path = path
  if(params.path[0] !== "/") params.path = "/"+params.path
  params.ship = params.ship || this.ship
  params.appl = params.appl || this.appl
  params.wire = params.wire || params.path

  if(typeof path != "string")
    throw new Error("You must specify a string path for urb.drop.")
  if(!params.appl) throw new Error("You must specify an appl for urb.drop.")
  
  url = "/~/is/"+this.gsig(params)+".json"
  method = "delete"
  this.req("delete",url,params,true,function(err,res) {
    if(cb) cb(err,res)
  })
}

window.urb.subscribe = function(params,cb) {   //  legacy interface
  if(!params) throw new Error("You must supply params to urb.subscribe")
  return window.urb.bind(params.path, params, cb, cb)
}

window.urb.unsubscribe = function(params,cb) { //  legacy intreface
  if(!params) throw new Error("You must supply params to urb.unsubscribe.")
  return window.urb.drop(params.path, params, cb)
}

window.urb.util = {
  isURL: function(s) {
     r = new RegExp('^(?!mailto:)(?:(?:http|https|ftp)://)(?:\\S+(?::\\S*)?@)?(?:(?:(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[0-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?:(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)(?:\\.(?:[a-z\\u00a1-\\uffff0-9]+-?)*[a-z\\u00a1-\\uffff0-9]+)*(?:\\.(?:[a-z\\u00a1-\\uffff]{2,})))|localhost)(?::\\d{2,5})?(?:(/|\\?|#)[^\\s]*)?$', 'i');
     return s.length < 2083 && r.test(s);
  },
  numDot: function(n) {
    _n = String(n)
    fun = function(s){
      if(s.length <= 3)
        return s
      return fun(s.slice(0,-3))+"."+s.slice(-3)
    }
    return fun((_n))
  },
  toDate: function (dat){
    var mils = Math.floor((0x10000 * dat.getUTCMilliseconds()) / 1000).toString(16)
    function pad(num, str){
      return ((new Array(num + 1)).join('0') + str).substr(-num,num)
    }
    return  '~' + dat.getUTCFullYear() + 
            '.' + (dat.getUTCMonth() + 1) + 
            '.' + dat.getUTCDate() + 
           '..' + pad(2, dat.getUTCHours()) + 
            '.' + pad(2, dat.getUTCMinutes()) + 
            '.' + pad(2, dat.getUTCSeconds()) + 
           '..' + pad(4, mils)
  },
  basepath: function(spur, pathname){
    spur = spur || ''
    if(spur === '/') spur = ''
    pathname = pathname || window.location.pathname

    base = ""

    if(pathname.indexOf("/~~") == 0)
      base = "/~~"
    if(pathname.indexOf("/~/as/") == 0)
      base = "/~/as/"+pathname.split("/")[3]
    if(pathname.indexOf("/~/away") == 0)
      base = "/~/away"
    
    return base+spur
  }
}