update

node_modules/a-sync-waterfall/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Elan Shanker
+
+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.

node_modules/a-sync-waterfall/README.md

@@ -0,0 +1,95 @@
+# a-sync-waterfall
+
+Simple, isolated sync/async waterfall module for JavaScript.
+
+Runs an array of functions in series, each passing their results to the next in
+the array. However, if any of the functions pass an error to the callback, the
+next function is not executed and the main callback is immediately called with
+the error.
+
+For browsers and node.js.
+
+## Installation
+* Just include a-sync-waterfall before your scripts.
+* `npm install a-sync-waterfall` if you’re using node.js.
+
+
+## Usage
+
+* `waterfall(tasks, optionalCallback, forceAsync);`
+* **tasks** - An array of functions to run, each function is passed a
+`callback(err, result1, result2, ...)` it must call on completion. The first
+argument is an error (which can be null) and any further arguments will be
+passed as arguments in order to the next task.
+* **optionalCallback** - An optional callback to run once all the functions have
+completed. This will be passed the results of the last task's callback.
+* **forceAsync** An optional flag that force tasks run asynchronously even if they are sync.
+
+##### Node.js:
+
+```javascript
+var waterfall = require('a-sync-waterfall');
+waterfall(tasks, callback);
+```
+
+##### Browser:
+
+```javascript
+var waterfall = require('a-sync-waterfall');
+waterfall(tasks, callback);
+
+// Default:
+window.waterfall(tasks, callback);
+```
+
+##### Tasks as Array of Functions
+
+```javascript
+waterfall([
+  function(callback){
+    callback(null, 'one', 'two');
+  },
+  function(arg1, arg2, callback){
+    callback(null, 'three');
+  },
+  function(arg1, callback){
+    // arg1 now equals 'three'
+    callback(null, 'done');
+  }
+], function (err, result) {
+  // result now equals 'done'
+});
+```
+
+##### Derive Tasks from an Array.map
+
+```javascript
+/* basic - no arguments */
+waterfall(myArray.map(function (arrayItem) {
+  return function (nextCallback) {
+    // same execution for each item, call the next one when done
+    doAsyncThingsWith(arrayItem, nextCallback);
+}}));
+
+/* with arguments, initializer function, and final callback */
+waterfall([function initializer (firstMapFunction) {
+    firstMapFunction(null, initialValue);
+  }].concat(myArray.map(function (arrayItem) {
+    return function (lastItemResult, nextCallback) {
+      // same execution for each item in the array
+      var itemResult = doThingsWith(arrayItem, lastItemResult);
+      // results carried along from each to the next
+      nextCallback(null, itemResult);
+}})), function (err, finalResult) {
+  // final callback
+});
+```
+
+## Acknowledgements
+Hat tip to [Caolan McMahon](https://github.com/caolan) and
+[Paul Miller](https://github.com/paulmillr), whose prior contributions this is
+based upon.
+Also [Elan Shanker](https://github.com/es128) from which this rep is forked
+
+## License
+[MIT](https://raw.github.com/hydiak/a-sync-waterfall/master/LICENSE)

node_modules/a-sync-waterfall/index.js

@@ -0,0 +1,83 @@
+// MIT license (by Elan Shanker).
+(function(globals) {
+  'use strict';
+
+  var executeSync = function(){
+    var args = Array.prototype.slice.call(arguments);
+    if (typeof args[0] === 'function'){
+      args[0].apply(null, args.splice(1));
+    }
+  };
+
+  var executeAsync = function(fn){
+    if (typeof setImmediate === 'function') {
+      setImmediate(fn);
+    } else if (typeof process !== 'undefined' && process.nextTick) {
+      process.nextTick(fn);
+    } else {
+      setTimeout(fn, 0);
+    }
+  };
+
+  var makeIterator = function (tasks) {
+    var makeCallback = function (index) {
+      var fn = function () {
+        if (tasks.length) {
+          tasks[index].apply(null, arguments);
+        }
+        return fn.next();
+      };
+      fn.next = function () {
+        return (index < tasks.length - 1) ? makeCallback(index + 1): null;
+      };
+      return fn;
+    };
+    return makeCallback(0);
+  };
+  
+  var _isArray = Array.isArray || function(maybeArray){
+    return Object.prototype.toString.call(maybeArray) === '[object Array]';
+  };
+
+  var waterfall = function (tasks, callback, forceAsync) {
+    var nextTick = forceAsync ? executeAsync : executeSync;
+    callback = callback || function () {};
+    if (!_isArray(tasks)) {
+      var err = new Error('First argument to waterfall must be an array of functions');
+      return callback(err);
+    }
+    if (!tasks.length) {
+      return callback();
+    }
+    var wrapIterator = function (iterator) {
+      return function (err) {
+        if (err) {
+          callback.apply(null, arguments);
+          callback = function () {};
+        } else {
+          var args = Array.prototype.slice.call(arguments, 1);
+          var next = iterator.next();
+          if (next) {
+            args.push(wrapIterator(next));
+          } else {
+            args.push(callback);
+          }
+          nextTick(function () {
+            iterator.apply(null, args);
+          });
+        }
+      };
+    };
+    wrapIterator(makeIterator(tasks))();
+  };
+
+  if (typeof define !== 'undefined' && define.amd) {
+    define([], function () {
+      return waterfall;
+    }); // RequireJS
+  } else if (typeof module !== 'undefined' && module.exports) {
+    module.exports = waterfall; // CommonJS
+  } else {
+    globals.waterfall = waterfall; // <script>
+  }
+})(this);

node_modules/a-sync-waterfall/package.json

@@ -0,0 +1,56 @@
+{
+  "_args": [
+    [
+      "a-sync-waterfall@1.0.1",
+      "/Users/tatiana/selfdefined"
+    ]
+  ],
+  "_from": "a-sync-waterfall@1.0.1",
+  "_id": "a-sync-waterfall@1.0.1",
+  "_inBundle": false,
+  "_integrity": "sha512-RYTOHHdWipFUliRFMCS4X2Yn2X8M87V/OpSqWzKKOGhzqyUxzyVmhHDH9sAvG+ZuQf/TAOFsLCpMw09I1ufUnA==",
+  "_location": "/a-sync-waterfall",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "version",
+    "registry": true,
+    "raw": "a-sync-waterfall@1.0.1",
+    "name": "a-sync-waterfall",
+    "escapedName": "a-sync-waterfall",
+    "rawSpec": "1.0.1",
+    "saveSpec": null,
+    "fetchSpec": "1.0.1"
+  },
+  "_requiredBy": [
+    "/nunjucks"
+  ],
+  "_resolved": "https://registry.npmjs.org/a-sync-waterfall/-/a-sync-waterfall-1.0.1.tgz",
+  "_spec": "1.0.1",
+  "_where": "/Users/tatiana/selfdefined",
+  "author": {
+    "name": "Gleb Khudyakov",
+    "url": "https://github.com/hydiak/a-sync-waterfall"
+  },
+  "bugs": {
+    "url": "https://github.com/hydiak/a-sync-waterfall/issues"
+  },
+  "dependencies": {},
+  "description": "Runs a list of async tasks, passing the results of each into the next one",
+  "homepage": "https://github.com/hydiak/a-sync-waterfall",
+  "keywords": [
+    "async",
+    "sync",
+    "waterfall",
+    "tasks",
+    "control",
+    "flow"
+  ],
+  "license": "MIT",
+  "main": "./index",
+  "name": "a-sync-waterfall",
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/hydiak/a-sync-waterfall.git"
+  },
+  "version": "1.0.1"
+}

node_modules/a-sync-waterfall/test.js

@@ -0,0 +1,77 @@
+"use strict";
+const waterfall = require('./index');
+
+var generateSyncTask = function(index) {
+	return function (x){
+		return function(cb){
+			console.log(x);
+			cb(null);
+		};
+	}(index);
+};
+
+
+var generateAsyncTask = function(index) {
+	return function (x){
+		return function(cb){
+			setTimeout(function(){
+				console.log(x);
+				cb(null);
+			}, 0);
+		};
+	}(index);
+};
+
+var generateSyncTasks = function(count){
+	var tasks = [];
+	for(var i=0; i<count; i++) {
+		tasks.push(generateSyncTask(i));
+	}
+	return tasks;
+}
+
+var generateAsyncTasks = function(count){
+	var tasks = [];
+	for(var i=0; i<count; i++) {
+		tasks.push(generateAsyncTask(i));
+	}
+	return tasks;
+}
+
+
+var generateRandomTasks = function(count){
+	var tasks = [];
+	for(var i=0; i<count; i++) {
+		Math.random() > .5 ? tasks.push(generateAsyncTask(i)) : tasks.push(generateSyncTask(i))
+	}
+	return tasks;
+}
+
+var done = function(){
+	console.log('done');
+}
+
+var testSync = function(){
+	waterfall(generateSyncTasks(10), done);
+	console.log('this text should be after waterfall');
+
+};
+
+var testAsync = function(){
+	waterfall(generateAsyncTasks(5), done);
+	console.log('this text should be before waterfall');
+};
+
+var testMixed = function(){
+	waterfall(generateRandomTasks(20), done);
+};
+
+
+console.log('testSync:');
+testSync();
+
+// console.log('\ntestAsync: ');
+// testAsync();
+
+console.log('\ntestMixed: ');
+testMixed();