(function () {

/* Imports */
var Meteor = Package.meteor.Meteor;
var WebApp = Package.webapp.WebApp;
var main = Package.webapp.main;
var WebAppInternals = Package.webapp.WebAppInternals;
var _ = Package.underscore._;

/* Package-scope variables */
var PickerImp, Picker;

(function(){

//////////////////////////////////////////////////////////////////////////////////////////
//                                                                                      //
// packages/meteorhacks_picker/packages/meteorhacks_picker.js                           //
//                                                                                      //
//////////////////////////////////////////////////////////////////////////////////////////
                                                                                        //
(function () {                                                                          // 1
                                                                                        // 2
///////////////////////////////////////////////////////////////////////////////////     // 3
//                                                                               //     // 4
// packages/meteorhacks:picker/lib/implementation.js                             //     // 5
//                                                                               //     // 6
///////////////////////////////////////////////////////////////////////////////////     // 7
                                                                                 //     // 8
var pathToRegexp = Npm.require('path-to-regexp');                                // 1   // 9
var Fiber = Npm.require('fibers');                                               // 2   // 10
var urlParse = Npm.require('url').parse;                                         // 3   // 11
                                                                                 // 4   // 12
PickerImp = function(filterFunction) {                                           // 5   // 13
  this.filterFunction = filterFunction;                                          // 6   // 14
  this.routes = [];                                                              // 7   // 15
  this.subRouters = [];                                                          // 8   // 16
  this.middlewares = [];                                                         // 9   // 17
}                                                                                // 10  // 18
                                                                                 // 11  // 19
PickerImp.prototype.middleware = function(callback) {                            // 12  // 20
  this.middlewares.push(callback);                                               // 13  // 21
};                                                                               // 14  // 22
                                                                                 // 15  // 23
PickerImp.prototype.route = function(path, callback) {                           // 16  // 24
  var regExp = pathToRegexp(path);                                               // 17  // 25
  regExp.callback = callback;                                                    // 18  // 26
  this.routes.push(regExp);                                                      // 19  // 27
  return this;                                                                   // 20  // 28
};                                                                               // 21  // 29
                                                                                 // 22  // 30
PickerImp.prototype.filter = function(callback) {                                // 23  // 31
  var subRouter = new PickerImp(callback);                                       // 24  // 32
  this.subRouters.push(subRouter);                                               // 25  // 33
  return subRouter;                                                              // 26  // 34
};                                                                               // 27  // 35
                                                                                 // 28  // 36
PickerImp.prototype._dispatch = function(req, res, bypass) {                     // 29  // 37
  var self = this;                                                               // 30  // 38
  var currentRoute = 0;                                                          // 31  // 39
  var currentSubRouter = 0;                                                      // 32  // 40
  var currentMiddleware = 0;                                                     // 33  // 41
                                                                                 // 34  // 42
  if(this.filterFunction) {                                                      // 35  // 43
    var result = this.filterFunction(req, res);                                  // 36  // 44
    if(!result) {                                                                // 37  // 45
      return bypass();                                                           // 38  // 46
    }                                                                            // 39  // 47
  }                                                                              // 40  // 48
                                                                                 // 41  // 49
  processNextMiddleware();                                                       // 42  // 50
  function processNextMiddleware () {                                            // 43  // 51
    var middleware = self.middlewares[currentMiddleware++];                      // 44  // 52
    if(middleware) {                                                             // 45  // 53
      self._processMiddleware(middleware, req, res, processNextMiddleware);      // 46  // 54
    } else {                                                                     // 47  // 55
      processNextRoute();                                                        // 48  // 56
    }                                                                            // 49  // 57
  }                                                                              // 50  // 58
                                                                                 // 51  // 59
  function processNextRoute () {                                                 // 52  // 60
    var route = self.routes[currentRoute++];                                     // 53  // 61
    if(route) {                                                                  // 54  // 62
      var uri = req.url.replace(/\?.*/, '');                                     // 55  // 63
      var m = uri.match(route);                                                  // 56  // 64
      if(m) {                                                                    // 57  // 65
        var params = self._buildParams(route.keys, m);                           // 58  // 66
        params.query = urlParse(req.url, true).query;                            // 59  // 67
        self._processRoute(route.callback, params, req, res, bypass);            // 60  // 68
      } else {                                                                   // 61  // 69
        processNextRoute();                                                      // 62  // 70
      }                                                                          // 63  // 71
    } else {                                                                     // 64  // 72
      processNextSubRouter();                                                    // 65  // 73
    }                                                                            // 66  // 74
  }                                                                              // 67  // 75
                                                                                 // 68  // 76
  function processNextSubRouter () {                                             // 69  // 77
    var subRouter = self.subRouters[currentSubRouter++];                         // 70  // 78
    if(subRouter) {                                                              // 71  // 79
      subRouter._dispatch(req, res, processNextSubRouter);                       // 72  // 80
    } else {                                                                     // 73  // 81
      bypass();                                                                  // 74  // 82
    }                                                                            // 75  // 83
  }                                                                              // 76  // 84
};                                                                               // 77  // 85
                                                                                 // 78  // 86
PickerImp.prototype._buildParams = function(keys, m) {                           // 79  // 87
  var params = {};                                                               // 80  // 88
  for(var lc=1; lc<m.length; lc++) {                                             // 81  // 89
    var key = keys[lc-1].name;                                                   // 82  // 90
    var value = m[lc];                                                           // 83  // 91
    params[key] = value;                                                         // 84  // 92
  }                                                                              // 85  // 93
                                                                                 // 86  // 94
  return params;                                                                 // 87  // 95
};                                                                               // 88  // 96
                                                                                 // 89  // 97
PickerImp.prototype._processRoute = function(callback, params, req, res, next) { // 90  // 98
  if(Fiber.current) {                                                            // 91  // 99
    doCall();                                                                    // 92  // 100
  } else {                                                                       // 93  // 101
    new Fiber(doCall).run();                                                     // 94  // 102
  }                                                                              // 95  // 103
                                                                                 // 96  // 104
  function doCall () {                                                           // 97  // 105
    callback.call(null, params, req, res, next);                                 // 98  // 106
  }                                                                              // 99  // 107
};                                                                               // 100
                                                                                 // 101
PickerImp.prototype._processMiddleware = function(middleware, req, res, next) {  // 102
  if(Fiber.current) {                                                            // 103
    doCall();                                                                    // 104
  } else {                                                                       // 105
    new Fiber(doCall).run();                                                     // 106
  }                                                                              // 107
                                                                                 // 108
  function doCall() {                                                            // 109
    middleware.call(null, req, res, next);                                       // 110
  }                                                                              // 111
};                                                                               // 112
///////////////////////////////////////////////////////////////////////////////////     // 121
                                                                                        // 122
}).call(this);                                                                          // 123
                                                                                        // 124
                                                                                        // 125
                                                                                        // 126
                                                                                        // 127
                                                                                        // 128
                                                                                        // 129
(function () {                                                                          // 130
                                                                                        // 131
///////////////////////////////////////////////////////////////////////////////////     // 132
//                                                                               //     // 133
// packages/meteorhacks:picker/lib/instance.js                                   //     // 134
//                                                                               //     // 135
///////////////////////////////////////////////////////////////////////////////////     // 136
                                                                                 //     // 137
Picker = new PickerImp();                                                        // 1   // 138
WebApp.rawConnectHandlers.use(function(req, res, next) {                         // 2   // 139
  Picker._dispatch(req, res, next);                                              // 3   // 140
});                                                                              // 4   // 141
                                                                                 // 5   // 142
///////////////////////////////////////////////////////////////////////////////////     // 143
                                                                                        // 144
}).call(this);                                                                          // 145
                                                                                        // 146
//////////////////////////////////////////////////////////////////////////////////////////

}).call(this);


/* Exports */
if (typeof Package === 'undefined') Package = {};
Package['meteorhacks:picker'] = {
  Picker: Picker
};

})();

//# sourceMappingURL=meteorhacks_picker.js.map