jass 0.9.1

data/vendor/node_modules/require-relative/index.js

@@ -0,0 +1,33 @@
+/*
+relative require
+*/'use strict';
+
+var path = require('path');
+var Module = require('module');
+
+var modules = {};
+
+var getModule = function(dir) {
+  var rootPath = dir ? path.resolve(dir) : process.cwd();
+  var rootName = path.join(rootPath, '@root');
+  var root = modules[rootName];
+  if (!root) {
+    root = new Module(rootName);
+    root.filename = rootName;
+    root.paths = Module._nodeModulePaths(rootPath);
+    modules[rootName] = root;
+  }
+  return root;
+};
+
+var requireRelative = function(requested, relativeTo) {
+  var root = getModule(relativeTo);
+  return root.require(requested);
+};
+
+requireRelative.resolve = function(requested, relativeTo) {
+  var root = getModule(relativeTo);
+  return Module._resolveFilename(requested, root);
+};
+
+module.exports = requireRelative;

data/vendor/node_modules/require-relative/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "require-relative",
+  "version": "0.8.7",
+  "description": "require and resolve modules relative to a path of your choice",
+  "main": "index.js",
+  "homepage": "https://github.com/kamicane/require-relative",
+  "author": "Valerio Proietti <@kamicane> (http://mad4milk.net)",
+  "keywords": [
+    "require",
+    "resolve",
+    "modules",
+    "relative"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/kamicane/require-relative/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/kamicane/require-relative.git"
+  }
+}

data/vendor/node_modules/resolve/index.js

@@ -0,0 +1,8 @@
+var core = require('./lib/core');
+var async = require('./lib/async');
+async.core = core;
+async.isCore = function isCore(x) { return core[x]; };
+async.sync = require('./lib/sync');
+
+exports = async;
+module.exports = async;

data/vendor/node_modules/resolve/lib/async.js

@@ -0,0 +1,203 @@
+var core = require('./core');
+var fs = require('fs');
+var path = require('path');
+var caller = require('./caller.js');
+var nodeModulesPaths = require('./node-modules-paths.js');
+
+module.exports = function resolve(x, options, callback) {
+    var cb = callback;
+    var opts = options || {};
+    if (typeof opts === 'function') {
+        cb = opts;
+        opts = {};
+    }
+    if (typeof x !== 'string') {
+        var err = new TypeError('Path must be a string.');
+        return process.nextTick(function () {
+            cb(err);
+        });
+    }
+
+    var isFile = opts.isFile || function (file, cb) {
+        fs.stat(file, function (err, stat) {
+            if (!err) {
+                return cb(null, stat.isFile() || stat.isFIFO());
+            }
+            if (err.code === 'ENOENT' || err.code === 'ENOTDIR') return cb(null, false);
+            return cb(err);
+        });
+    };
+    var readFile = opts.readFile || fs.readFile;
+
+    var extensions = opts.extensions || ['.js'];
+    var y = opts.basedir || path.dirname(caller());
+
+    opts.paths = opts.paths || [];
+
+    if (/^(?:\.\.?(?:\/|$)|\/|([A-Za-z]:)?[/\\])/.test(x)) {
+        var res = path.resolve(y, x);
+        if (x === '..' || x.slice(-1) === '/') res += '/';
+        if (/\/$/.test(x) && res === y) {
+            loadAsDirectory(res, opts.package, onfile);
+        } else loadAsFile(res, opts.package, onfile);
+    } else loadNodeModules(x, y, function (err, n, pkg) {
+        if (err) cb(err);
+        else if (n) cb(null, n, pkg);
+        else if (core[x]) return cb(null, x);
+        else {
+            var moduleError = new Error("Cannot find module '" + x + "' from '" + y + "'");
+            moduleError.code = 'MODULE_NOT_FOUND';
+            cb(moduleError);
+        }
+    });
+
+    function onfile(err, m, pkg) {
+        if (err) cb(err);
+        else if (m) cb(null, m, pkg);
+        else loadAsDirectory(res, function (err, d, pkg) {
+            if (err) cb(err);
+            else if (d) cb(null, d, pkg);
+            else {
+                var moduleError = new Error("Cannot find module '" + x + "' from '" + y + "'");
+                moduleError.code = 'MODULE_NOT_FOUND';
+                cb(moduleError);
+            }
+        });
+    }
+
+    function loadAsFile(x, thePackage, callback) {
+        var loadAsFilePackage = thePackage;
+        var cb = callback;
+        if (typeof loadAsFilePackage === 'function') {
+            cb = loadAsFilePackage;
+            loadAsFilePackage = undefined;
+        }
+
+        var exts = [''].concat(extensions);
+        load(exts, x, loadAsFilePackage);
+
+        function load(exts, x, loadPackage) {
+            if (exts.length === 0) return cb(null, undefined, loadPackage);
+            var file = x + exts[0];
+
+            var pkg = loadPackage;
+            if (pkg) onpkg(null, pkg);
+            else loadpkg(path.dirname(file), onpkg);
+
+            function onpkg(err, pkg_, dir) {
+                pkg = pkg_;
+                if (err) return cb(err);
+                if (dir && pkg && opts.pathFilter) {
+                    var rfile = path.relative(dir, file);
+                    var rel = rfile.slice(0, rfile.length - exts[0].length);
+                    var r = opts.pathFilter(pkg, x, rel);
+                    if (r) return load(
+                        [''].concat(extensions.slice()),
+                        path.resolve(dir, r),
+                        pkg
+                    );
+                }
+                isFile(file, onex);
+            }
+            function onex(err, ex) {
+                if (err) return cb(err);
+                if (ex) return cb(null, file, pkg);
+                load(exts.slice(1), x, pkg);
+            }
+        }
+    }
+
+    function loadpkg(dir, cb) {
+        if (dir === '' || dir === '/') return cb(null);
+        if (process.platform === 'win32' && (/^\w:[/\\]*$/).test(dir)) {
+            return cb(null);
+        }
+        if (/[/\\]node_modules[/\\]*$/.test(dir)) return cb(null);
+
+        var pkgfile = path.join(dir, 'package.json');
+        isFile(pkgfile, function (err, ex) {
+            // on err, ex is false
+            if (!ex) return loadpkg(path.dirname(dir), cb);
+
+            readFile(pkgfile, function (err, body) {
+                if (err) cb(err);
+                try { var pkg = JSON.parse(body); } catch (jsonErr) {}
+
+                if (pkg && opts.packageFilter) {
+                    pkg = opts.packageFilter(pkg, pkgfile);
+                }
+                cb(null, pkg, dir);
+            });
+        });
+    }
+
+    function loadAsDirectory(x, loadAsDirectoryPackage, callback) {
+        var cb = callback;
+        var fpkg = loadAsDirectoryPackage;
+        if (typeof fpkg === 'function') {
+            cb = fpkg;
+            fpkg = opts.package;
+        }
+
+        var pkgfile = path.join(x, 'package.json');
+        isFile(pkgfile, function (err, ex) {
+            if (err) return cb(err);
+            if (!ex) return loadAsFile(path.join(x, 'index'), fpkg, cb);
+
+            readFile(pkgfile, function (err, body) {
+                if (err) return cb(err);
+                try {
+                    var pkg = JSON.parse(body);
+                } catch (jsonErr) {}
+
+                if (opts.packageFilter) {
+                    pkg = opts.packageFilter(pkg, pkgfile);
+                }
+
+                if (pkg.main) {
+                    if (pkg.main === '.' || pkg.main === './') {
+                        pkg.main = 'index';
+                    }
+                    loadAsFile(path.resolve(x, pkg.main), pkg, function (err, m, pkg) {
+                        if (err) return cb(err);
+                        if (m) return cb(null, m, pkg);
+                        if (!pkg) return loadAsFile(path.join(x, 'index'), pkg, cb);
+
+                        var dir = path.resolve(x, pkg.main);
+                        loadAsDirectory(dir, pkg, function (err, n, pkg) {
+                            if (err) return cb(err);
+                            if (n) return cb(null, n, pkg);
+                            loadAsFile(path.join(x, 'index'), pkg, cb);
+                        });
+                    });
+                    return;
+                }
+
+                loadAsFile(path.join(x, '/index'), pkg, cb);
+            });
+        });
+    }
+
+    function processDirs(cb, dirs) {
+        if (dirs.length === 0) return cb(null, undefined);
+        var dir = dirs[0];
+
+        var file = path.join(dir, x);
+        loadAsFile(file, undefined, onfile);
+
+        function onfile(err, m, pkg) {
+            if (err) return cb(err);
+            if (m) return cb(null, m, pkg);
+            loadAsDirectory(path.join(dir, x), undefined, ondir);
+        }
+
+        function ondir(err, n, pkg) {
+            if (err) return cb(err);
+            if (n) return cb(null, n, pkg);
+            processDirs(cb, dirs.slice(1));
+        }
+    }
+    function loadNodeModules(x, start, cb) {
+        processDirs(cb, nodeModulesPaths(start, opts));
+    }
+};

data/vendor/node_modules/resolve/lib/caller.js

@@ -0,0 +1,8 @@
+module.exports = function () {
+    // see https://code.google.com/p/v8/wiki/JavaScriptStackTraceApi
+    var origPrepareStackTrace = Error.prepareStackTrace;
+    Error.prepareStackTrace = function (_, stack) { return stack; };
+    var stack = (new Error()).stack;
+    Error.prepareStackTrace = origPrepareStackTrace;
+    return stack[2].getFileName();
+};

data/vendor/node_modules/resolve/lib/core.js

@@ -0,0 +1,53 @@
+var current = (process.versions && process.versions.node && process.versions.node.split('.')) || [];
+
+function specifierIncluded(specifier) {
+    var parts = specifier.split(' ');
+    var op = parts[0];
+    var versionParts = parts[1].split('.');
+
+    for (var i = 0; i < 3; ++i) {
+        var cur = Number(current[i] || 0);
+        var ver = Number(versionParts[i] || 0);
+        if (cur === ver) {
+            continue; // eslint-disable-line no-restricted-syntax, no-continue
+        }
+        if (op === '<') {
+            return cur < ver;
+        } else if (op === '>=') {
+            return cur >= ver;
+        } else {
+            return false;
+        }
+    }
+    return op === '>=';
+}
+
+function matchesRange(range) {
+    var specifiers = range.split(/ ?&& ?/);
+    if (specifiers.length === 0) { return false; }
+    for (var i = 0; i < specifiers.length; ++i) {
+        if (!specifierIncluded(specifiers[i])) { return false; }
+    }
+    return true;
+}
+
+function versionIncluded(specifierValue) {
+    if (typeof specifierValue === 'boolean') { return specifierValue; }
+    if (specifierValue && typeof specifierValue === 'object') {
+        for (var i = 0; i < specifierValue.length; ++i) {
+            if (matchesRange(specifierValue[i])) { return true; }
+        }
+        return false;
+    }
+    return matchesRange(specifierValue);
+}
+
+var data = require('./core.json');
+
+var core = {};
+for (var mod in data) { // eslint-disable-line no-restricted-syntax
+    if (Object.prototype.hasOwnProperty.call(data, mod)) {
+        core[mod] = versionIncluded(data[mod]);
+    }
+}
+module.exports = core;

data/vendor/node_modules/resolve/lib/core.json

@@ -0,0 +1,69 @@
+{
+    "assert": true,
+    "async_hooks": ">= 8",
+    "buffer_ieee754": "< 0.9.7",
+    "buffer": true,
+    "child_process": true,
+    "cluster": true,
+    "console": true,
+    "constants": true,
+    "crypto": true,
+    "_debugger": "< 8",
+    "dgram": true,
+    "dns": true,
+    "domain": true,
+    "events": true,
+    "freelist": "< 6",
+    "fs": true,
+    "_http_agent": ">= 0.11.1",
+    "_http_client": ">= 0.11.1",
+    "_http_common": ">= 0.11.1",
+    "_http_incoming": ">= 0.11.1",
+    "_http_outgoing": ">= 0.11.1",
+    "_http_server": ">= 0.11.1",
+    "http": true,
+    "http2": ">= 8.8",
+    "https": true,
+    "inspector": ">= 8.0.0",
+    "_linklist": "< 8",
+    "module": true,
+    "net": true,
+    "node-inspect/lib/_inspect": ">= 7.6.0",
+    "node-inspect/lib/internal/inspect_client": ">= 7.6.0",
+    "node-inspect/lib/internal/inspect_repl": ">= 7.6.0",
+    "os": true,
+    "path": true,
+    "perf_hooks": ">= 8.5",
+    "process": ">= 1",
+    "punycode": true,
+    "querystring": true,
+    "readline": true,
+    "repl": true,
+    "smalloc": ">= 0.11.5 && < 3",
+    "_stream_duplex": ">= 0.9.4",
+    "_stream_transform": ">= 0.9.4",
+    "_stream_wrap": ">= 1.4.1",
+    "_stream_passthrough": ">= 0.9.4",
+    "_stream_readable": ">= 0.9.4",
+    "_stream_writable": ">= 0.9.4",
+    "stream": true,
+    "string_decoder": true,
+    "sys": true,
+    "timers": true,
+    "_tls_common": ">= 0.11.13",
+    "_tls_legacy": ">= 0.11.3",
+    "_tls_wrap": ">= 0.11.3",
+    "tls": true,
+    "tty": true,
+    "url": true,
+    "util": true,
+    "v8/tools/codemap": [">= 4.4.0 && < 5", ">= 5.2.0"],
+    "v8/tools/consarray": [">= 4.4.0 && < 5", ">= 5.2.0"],
+    "v8/tools/csvparser": [">= 4.4.0 && < 5", ">= 5.2.0"],
+    "v8/tools/logreader": [">= 4.4.0 && < 5", ">= 5.2.0"],
+    "v8/tools/profile_view": [">= 4.4.0 && < 5", ">= 5.2.0"],
+    "v8/tools/splaytree": [">= 4.4.0 && < 5", ">= 5.2.0"],
+    "v8": ">= 1",
+    "vm": true,
+    "zlib": true
+}

data/vendor/node_modules/resolve/lib/node-modules-paths.js

@@ -0,0 +1,45 @@
+var path = require('path');
+var fs = require('fs');
+var parse = path.parse || require('path-parse');
+
+module.exports = function nodeModulesPaths(start, opts) {
+    var modules = opts && opts.moduleDirectory
+        ? [].concat(opts.moduleDirectory)
+        : ['node_modules'];
+
+    // ensure that `start` is an absolute path at this point,
+    // resolving against the process' current working directory
+    var absoluteStart = path.resolve(start);
+
+    if (opts && opts.preserveSymlinks === false) {
+        try {
+            absoluteStart = fs.realpathSync(absoluteStart);
+        } catch (err) {
+            if (err.code !== 'ENOENT') {
+                throw err;
+            }
+        }
+    }
+
+    var prefix = '/';
+    if (/^([A-Za-z]:)/.test(absoluteStart)) {
+        prefix = '';
+    } else if (/^\\\\/.test(absoluteStart)) {
+        prefix = '\\\\';
+    }
+
+    var paths = [absoluteStart];
+    var parsed = parse(absoluteStart);
+    while (parsed.dir !== paths[paths.length - 1]) {
+        paths.push(parsed.dir);
+        parsed = parse(parsed.dir);
+    }
+
+    var dirs = paths.reduce(function (dirs, aPath) {
+        return dirs.concat(modules.map(function (moduleDir) {
+            return path.join(prefix, aPath, moduleDir);
+        }));
+    }, []);
+
+    return opts && opts.paths ? dirs.concat(opts.paths) : dirs;
+};