vaderjs 1.3.3 → 1.3.4

package/create-vader-app/node_modules/process/browser.js

@@ -0,0 +1,184 @@
+// shim for using process in browser
+var process = module.exports = {};
+
+// cached from whatever global is present so that test runners that stub it
+// don't break things.  But we need to wrap it in a try catch in case it is
+// wrapped in strict mode code which doesn't define any globals.  It's inside a
+// function because try/catches deoptimize in certain engines.
+
+var cachedSetTimeout;
+var cachedClearTimeout;
+
+function defaultSetTimout() {
+    throw new Error('setTimeout has not been defined');
+}
+function defaultClearTimeout () {
+    throw new Error('clearTimeout has not been defined');
+}
+(function () {
+    try {
+        if (typeof setTimeout === 'function') {
+            cachedSetTimeout = setTimeout;
+        } else {
+            cachedSetTimeout = defaultSetTimout;
+        }
+    } catch (e) {
+        cachedSetTimeout = defaultSetTimout;
+    }
+    try {
+        if (typeof clearTimeout === 'function') {
+            cachedClearTimeout = clearTimeout;
+        } else {
+            cachedClearTimeout = defaultClearTimeout;
+        }
+    } catch (e) {
+        cachedClearTimeout = defaultClearTimeout;
+    }
+} ())
+function runTimeout(fun) {
+    if (cachedSetTimeout === setTimeout) {
+        //normal enviroments in sane situations
+        return setTimeout(fun, 0);
+    }
+    // if setTimeout wasn't available but was latter defined
+    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
+        cachedSetTimeout = setTimeout;
+        return setTimeout(fun, 0);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedSetTimeout(fun, 0);
+    } catch(e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
+            return cachedSetTimeout.call(null, fun, 0);
+        } catch(e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
+            return cachedSetTimeout.call(this, fun, 0);
+        }
+    }
+
+
+}
+function runClearTimeout(marker) {
+    if (cachedClearTimeout === clearTimeout) {
+        //normal enviroments in sane situations
+        return clearTimeout(marker);
+    }
+    // if clearTimeout wasn't available but was latter defined
+    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
+        cachedClearTimeout = clearTimeout;
+        return clearTimeout(marker);
+    }
+    try {
+        // when when somebody has screwed with setTimeout but no I.E. maddness
+        return cachedClearTimeout(marker);
+    } catch (e){
+        try {
+            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
+            return cachedClearTimeout.call(null, marker);
+        } catch (e){
+            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
+            // Some versions of I.E. have different rules for clearTimeout vs setTimeout
+            return cachedClearTimeout.call(this, marker);
+        }
+    }
+
+
+
+}
+var queue = [];
+var draining = false;
+var currentQueue;
+var queueIndex = -1;
+
+function cleanUpNextTick() {
+    if (!draining || !currentQueue) {
+        return;
+    }
+    draining = false;
+    if (currentQueue.length) {
+        queue = currentQueue.concat(queue);
+    } else {
+        queueIndex = -1;
+    }
+    if (queue.length) {
+        drainQueue();
+    }
+}
+
+function drainQueue() {
+    if (draining) {
+        return;
+    }
+    var timeout = runTimeout(cleanUpNextTick);
+    draining = true;
+
+    var len = queue.length;
+    while(len) {
+        currentQueue = queue;
+        queue = [];
+        while (++queueIndex < len) {
+            if (currentQueue) {
+                currentQueue[queueIndex].run();
+            }
+        }
+        queueIndex = -1;
+        len = queue.length;
+    }
+    currentQueue = null;
+    draining = false;
+    runClearTimeout(timeout);
+}
+
+process.nextTick = function (fun) {
+    var args = new Array(arguments.length - 1);
+    if (arguments.length > 1) {
+        for (var i = 1; i < arguments.length; i++) {
+            args[i - 1] = arguments[i];
+        }
+    }
+    queue.push(new Item(fun, args));
+    if (queue.length === 1 && !draining) {
+        runTimeout(drainQueue);
+    }
+};
+
+// v8 likes predictible objects
+function Item(fun, array) {
+    this.fun = fun;
+    this.array = array;
+}
+Item.prototype.run = function () {
+    this.fun.apply(null, this.array);
+};
+process.title = 'browser';
+process.browser = true;
+process.env = {};
+process.argv = [];
+process.version = ''; // empty string to avoid regexp issues
+process.versions = {};
+
+function noop() {}
+
+process.on = noop;
+process.addListener = noop;
+process.once = noop;
+process.off = noop;
+process.removeListener = noop;
+process.removeAllListeners = noop;
+process.emit = noop;
+process.prependListener = noop;
+process.prependOnceListener = noop;
+
+process.listeners = function (name) { return [] }
+
+process.binding = function (name) {
+    throw new Error('process.binding is not supported');
+};
+
+process.cwd = function () { return '/' };
+process.chdir = function (dir) {
+    throw new Error('process.chdir is not supported');
+};
+process.umask = function() { return 0; };

package/create-vader-app/node_modules/process/index.js

@@ -0,0 +1,2 @@
+// for now just expose the builtin process global from node.js
+module.exports = global.process;

package/create-vader-app/node_modules/process/package.json

@@ -0,0 +1,27 @@
+{
+  "author": "Roman Shtylman <shtylman@gmail.com>",
+  "name": "process",
+  "description": "process information for node.js and browsers",
+  "keywords": [
+    "process"
+  ],
+  "scripts": {
+    "test": "mocha test.js",
+    "browser": "zuul --no-coverage --ui mocha-bdd --local 8080 -- test.js"
+  },
+  "version": "0.11.10",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/shtylman/node-process.git"
+  },
+  "license": "MIT",
+  "browser": "./browser.js",
+  "main": "./index.js",
+  "engines": {
+    "node": ">= 0.6.0"
+  },
+  "devDependencies": {
+    "mocha": "2.2.1",
+    "zuul": "^3.10.3"
+  }
+}

package/create-vader-app/node_modules/process/test.js

@@ -0,0 +1,199 @@
+var assert = require('assert');
+var ourProcess = require('./browser');
+describe('test against our process', function () {
+    test(ourProcess);
+});
+if (!process.browser) {
+  describe('test against node', function () {
+    test(process);
+  });
+  vmtest();
+}
+function test (ourProcess) {
+    describe('test arguments', function () {
+        it ('works', function (done) {
+          var order = 0;
+
+
+          ourProcess.nextTick(function (num) {
+              assert.equal(num, order++, 'first one works');
+              ourProcess.nextTick(function (num) {
+                assert.equal(num, order++, 'recursive one is 4th');
+              }, 3);
+          }, 0);
+          ourProcess.nextTick(function (num) {
+              assert.equal(num, order++, 'second one starts');
+              ourProcess.nextTick(function (num) {
+                assert.equal(num, order++, 'this is third');
+                ourProcess.nextTick(function (num) {
+                    assert.equal(num, order++, 'this is last');
+                    done();
+                }, 5);
+            }, 4);
+          }, 1);
+          ourProcess.nextTick(function (num) {
+
+              assert.equal(num, order++, '3rd schedualed happens after the error');
+          }, 2);
+        });
+    });
+if (!process.browser) {
+    describe('test errors', function (t) {
+        it ('works', function (done) {
+        var order = 0;
+        process.removeAllListeners('uncaughtException');
+        process.once('uncaughtException', function(err) {
+            assert.equal(2, order++, 'error is third');
+            ourProcess.nextTick(function () {
+                assert.equal(5, order++, 'schedualed in error is last');
+                done();
+            });
+        });
+        ourProcess.nextTick(function () {
+            assert.equal(0, order++, 'first one works');
+            ourProcess.nextTick(function () {
+            assert.equal(4, order++, 'recursive one is 4th');
+            });
+        });
+        ourProcess.nextTick(function () {
+            assert.equal(1, order++, 'second one starts');
+            throw(new Error('an error is thrown'));
+        });
+        ourProcess.nextTick(function () {
+            assert.equal(3, order++, '3rd schedualed happens after the error');
+        });
+        });
+    });
+}
+    describe('rename globals', function (t) {
+      var oldTimeout = setTimeout;
+      var oldClear = clearTimeout;
+
+      it('clearTimeout', function (done){
+
+        var ok = true;
+        clearTimeout = function () {
+          ok = false;
+        }
+        var ran = false;
+        function cleanup() {
+          clearTimeout = oldClear;
+          var err;
+          try {
+            assert.ok(ok, 'fake clearTimeout ran');
+            assert.ok(ran, 'should have run');
+          } catch (e) {
+            err = e;
+          }
+          done(err);
+        }
+        setTimeout(cleanup, 1000);
+        ourProcess.nextTick(function () {
+          ran = true;
+        });
+      });
+      it('just setTimeout', function (done){
+
+
+        setTimeout = function () {
+          setTimeout = oldTimeout;
+          try {
+            assert.ok(false, 'fake setTimeout called')
+          } catch (e) {
+            done(e);
+          }
+
+        }
+
+        ourProcess.nextTick(function () {
+          setTimeout = oldTimeout;
+          done();
+        });
+      });
+    });
+}
+function vmtest() {
+  var vm = require('vm');
+  var fs = require('fs');
+  var process =  fs.readFileSync('./browser.js', {encoding: 'utf8'});
+
+
+  describe('should work in vm in strict mode with no globals', function () {
+    it('should parse', function (done) {
+      var str = '"use strict";var module = {exports:{}};';
+      str += process;
+      str += 'this.works = process.browser;';
+      var script = new vm.Script(str);
+      var context = {
+        works: false
+      };
+      script.runInNewContext(context);
+      assert.ok(context.works);
+      done();
+    });
+    it('setTimeout throws error', function (done) {
+      var str = '"use strict";var module = {exports:{}};';
+      str += process;
+      str += 'try {process.nextTick(function () {})} catch (e){this.works = e;}';
+      var script = new vm.Script(str);
+      var context = {
+        works: false
+      };
+      script.runInNewContext(context);
+      assert.ok(context.works);
+      done();
+    });
+    it('should generally work', function (done) {
+      var str = '"use strict";var module = {exports:{}};';
+      str += process;
+      str += 'process.nextTick(function () {assert.ok(true);done();})';
+      var script = new vm.Script(str);
+      var context = {
+        clearTimeout: clearTimeout,
+        setTimeout: setTimeout,
+        done: done,
+        assert: assert
+      };
+      script.runInNewContext(context);
+    });
+    it('late defs setTimeout', function (done) {
+      var str = '"use strict";var module = {exports:{}};';
+      str += process;
+      str += 'var setTimeout = hiddenSetTimeout;process.nextTick(function () {assert.ok(true);done();})';
+      var script = new vm.Script(str);
+      var context = {
+        clearTimeout: clearTimeout,
+        hiddenSetTimeout: setTimeout,
+        done: done,
+        assert: assert
+      };
+      script.runInNewContext(context);
+    });
+    it('late defs clearTimeout', function (done) {
+      var str = '"use strict";var module = {exports:{}};';
+      str += process;
+      str += 'var clearTimeout = hiddenClearTimeout;process.nextTick(function () {assert.ok(true);done();})';
+      var script = new vm.Script(str);
+      var context = {
+        hiddenClearTimeout: clearTimeout,
+        setTimeout: setTimeout,
+        done: done,
+        assert: assert
+      };
+      script.runInNewContext(context);
+    });
+    it('late defs setTimeout and then redefine', function (done) {
+      var str = '"use strict";var module = {exports:{}};';
+      str += process;
+      str += 'var setTimeout = hiddenSetTimeout;process.nextTick(function () {setTimeout = function (){throw new Error("foo")};hiddenSetTimeout(function(){process.nextTick(function (){assert.ok(true);done();});});});';
+      var script = new vm.Script(str);
+      var context = {
+        clearTimeout: clearTimeout,
+        hiddenSetTimeout: setTimeout,
+        done: done,
+        assert: assert
+      };
+      script.runInNewContext(context);
+    });
+  });
+}

package/create-vader-app/node_modules/universalify/LICENSE

@@ -0,0 +1,20 @@
+(The MIT License)
+
+Copyright (c) 2017, Ryan Zimmerman <opensrc@ryanzim.com>
+
+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.

package/create-vader-app/node_modules/universalify/README.md

@@ -0,0 +1,76 @@
+# universalify
+
+[![Travis branch](https://img.shields.io/travis/RyanZim/universalify/master.svg)](https://travis-ci.org/RyanZim/universalify)
+![Coveralls github branch](https://img.shields.io/coveralls/github/RyanZim/universalify/master.svg)
+![npm](https://img.shields.io/npm/dm/universalify.svg)
+![npm](https://img.shields.io/npm/l/universalify.svg)
+
+Make a callback- or promise-based function support both promises and callbacks.
+
+Uses the native promise implementation.
+
+## Installation
+
+```bash
+npm install universalify
+```
+
+## API
+
+### `universalify.fromCallback(fn)`
+
+Takes a callback-based function to universalify, and returns the universalified  function.
+
+Function must take a callback as the last parameter that will be called with the signature `(error, result)`. `universalify` does not support calling the callback with three or more arguments, and does not ensure that the callback is only called once.
+
+```js
+function callbackFn (n, cb) {
+  setTimeout(() => cb(null, n), 15)
+}
+
+const fn = universalify.fromCallback(callbackFn)
+
+// Works with Promises:
+fn('Hello World!')
+.then(result => console.log(result)) // -> Hello World!
+.catch(error => console.error(error))
+
+// Works with Callbacks:
+fn('Hi!', (error, result) => {
+  if (error) return console.error(error)
+  console.log(result)
+  // -> Hi!
+})
+```
+
+### `universalify.fromPromise(fn)`
+
+Takes a promise-based function to universalify, and returns the universalified  function.
+
+Function must return a valid JS promise. `universalify` does not ensure that a valid promise is returned.
+
+```js
+function promiseFn (n) {
+  return new Promise(resolve => {
+    setTimeout(() => resolve(n), 15)
+  })
+}
+
+const fn = universalify.fromPromise(promiseFn)
+
+// Works with Promises:
+fn('Hello World!')
+.then(result => console.log(result)) // -> Hello World!
+.catch(error => console.error(error))
+
+// Works with Callbacks:
+fn('Hi!', (error, result) => {
+  if (error) return console.error(error)
+  console.log(result)
+  // -> Hi!
+})
+```
+
+## License
+
+MIT

package/create-vader-app/node_modules/universalify/index.js

@@ -0,0 +1,24 @@
+'use strict'
+
+exports.fromCallback = function (fn) {
+  return Object.defineProperty(function (...args) {
+    if (typeof args[args.length - 1] === 'function') fn.apply(this, args)
+    else {
+      return new Promise((resolve, reject) => {
+        fn.call(
+          this,
+          ...args,
+          (err, res) => (err != null) ? reject(err) : resolve(res)
+        )
+      })
+    }
+  }, 'name', { value: fn.name })
+}
+
+exports.fromPromise = function (fn) {
+  return Object.defineProperty(function (...args) {
+    const cb = args[args.length - 1]
+    if (typeof cb !== 'function') return fn.apply(this, args)
+    else fn.apply(this, args.slice(0, -1)).then(r => cb(null, r), cb)
+  }, 'name', { value: fn.name })
+}

package/create-vader-app/node_modules/universalify/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "universalify",
+  "version": "2.0.0",
+  "description": "Make a callback- or promise-based function support both promises and callbacks.",
+  "keywords": [
+    "callback",
+    "native",
+    "promise"
+  ],
+  "homepage": "https://github.com/RyanZim/universalify#readme",
+  "bugs": "https://github.com/RyanZim/universalify/issues",
+  "license": "MIT",
+  "author": "Ryan Zimmerman <opensrc@ryanzim.com>",
+  "files": [
+    "index.js"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/RyanZim/universalify.git"
+  },
+  "scripts": {
+    "test": "standard && nyc tape test/*.js | colortape"
+  },
+  "devDependencies": {
+    "colortape": "^0.1.2",
+    "coveralls": "^3.0.1",
+    "nyc": "^15.0.0",
+    "standard": "^14.3.1",
+    "tape": "^5.0.1"
+  },
+  "engines": {
+    "node": ">= 10.0.0"
+  }
+}

package/create-vader-app/node_modules/util/LICENSE

@@ -0,0 +1,18 @@
+Copyright Joyent, Inc. and other Node contributors. All rights reserved.
+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.

package/create-vader-app/node_modules/util/README.md

@@ -0,0 +1,15 @@
+# util
+
+[![Build Status](https://travis-ci.org/defunctzombie/node-util.png?branch=master)](https://travis-ci.org/defunctzombie/node-util)
+
+node.js [util](http://nodejs.org/api/util.html) module as a module
+
+## install via [npm](npmjs.org)
+
+```shell
+npm install util
+```
+
+## browser support
+
+This module also works in modern browsers. If you need legacy browser support you will need to polyfill ES5 features.

package/create-vader-app/node_modules/util/package.json

@@ -0,0 +1,35 @@
+{
+  "author": {
+    "name": "Joyent",
+    "url": "http://www.joyent.com"
+  },
+  "name": "util",
+  "description": "Node.JS util module",
+  "keywords": [
+    "util"
+  ],
+  "version": "0.10.4",
+  "homepage": "https://github.com/defunctzombie/node-util",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/defunctzombie/node-util"
+  },
+  "main": "./util.js",
+  "files": [
+    "util.js",
+    "support"
+  ],
+  "scripts": {
+    "test": "node test/node/*.js && zuul test/browser/*.js"
+  },
+  "dependencies": {
+    "inherits": "2.0.3"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "zuul": "~1.0.9"
+  },
+  "browser": {
+    "./support/isBuffer.js": "./support/isBufferBrowser.js"
+  }
+}

package/create-vader-app/node_modules/util/support/isBuffer.js

@@ -0,0 +1,3 @@
+module.exports = function isBuffer(arg) {
+  return arg instanceof Buffer;
+}

package/create-vader-app/node_modules/util/support/isBufferBrowser.js

@@ -0,0 +1,6 @@
+module.exports = function isBuffer(arg) {
+  return arg && typeof arg === 'object'
+    && typeof arg.copy === 'function'
+    && typeof arg.fill === 'function'
+    && typeof arg.readUInt8 === 'function';
+}