jass 0.9.1

data/vendor/node_modules/is-extglob/index.js

@@ -0,0 +1,11 @@
+/*!
+ * is-extglob <https://github.com/jonschlinkert/is-extglob>
+ *
+ * Copyright (c) 2014-2015, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+module.exports = function isExtglob(str) {
+  return typeof str === 'string'
+    && /[@?!+*]\(/.test(str);
+};

data/vendor/node_modules/is-extglob/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "is-extglob",
+  "description": "Returns true if a string has an extglob.",
+  "version": "1.0.0",
+  "homepage": "https://github.com/jonschlinkert/is-extglob",
+  "author": {
+    "name": "Jon Schlinkert",
+    "url": "https://github.com/jonschlinkert"
+  },
+  "repository": "jonschlinkert/is-extglob",
+  "bugs": {
+    "url": "https://github.com/jonschlinkert/is-extglob/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha",
+    "prepublish": "browserify -o browser.js -e index.js"
+  },
+  "devDependencies": {
+    "mocha": "*",
+    "should": "*"
+  },
+  "keywords": [
+    "bash",
+    "braces",
+    "check",
+    "exec",
+    "extglob",
+    "expression",
+    "glob",
+    "globbing",
+    "globstar",
+    "match",
+    "matches",
+    "pattern",
+    "regex",
+    "regular",
+    "string",
+    "test"
+  ]
+}

data/vendor/node_modules/is-glob/index.js

@@ -0,0 +1,14 @@
+/*!
+ * is-glob <https://github.com/jonschlinkert/is-glob>
+ *
+ * Copyright (c) 2014-2015, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+var isExtglob = require('is-extglob');
+
+module.exports = function isGlob(str) {
+  return typeof str === 'string'
+    && (/[*!?{}(|)[\]]/.test(str)
+     || isExtglob(str));
+};

data/vendor/node_modules/is-glob/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "is-glob",
+  "description": "Returns `true` if the given string looks like a glob pattern or an extglob pattern. This makes it easy to create code that only uses external modules like node-glob when necessary, resulting in much faster code execution and initialization time, and a better user experience.",
+  "version": "2.0.1",
+  "homepage": "https://github.com/jonschlinkert/is-glob",
+  "author": {
+    "name": "Jon Schlinkert",
+    "url": "https://github.com/jonschlinkert"
+  },
+  "repository": "jonschlinkert/is-glob",
+  "bugs": {
+    "url": "https://github.com/jonschlinkert/is-glob/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "dependencies": {
+    "is-extglob": "^1.0.0"
+  },
+  "devDependencies": {
+    "mocha": "*"
+  },
+  "keywords": [
+    "bash",
+    "braces",
+    "check",
+    "exec",
+    "extglob",
+    "expression",
+    "glob",
+    "globbing",
+    "globstar",
+    "match",
+    "matches",
+    "pattern",
+    "regex",
+    "regular",
+    "string",
+    "test"
+  ],
+  "verb": {
+    "related": {
+      "list": [
+        "has-glob",
+        "is-extglob",
+        "is-posix-bracket",
+        "is-valid-glob",
+        "micromatch"
+      ]
+    }
+  }
+}

data/vendor/node_modules/is-module/index.js

@@ -0,0 +1,11 @@
+
+// no idea what these regular expressions do,
+// but i extracted it from https://github.com/yahoo/js-module-formats/blob/master/index.js#L18
+var ES6ImportExportRegExp = /(?:^\s*|[}{\(\);,\n]\s*)(import\s+['"]|(import|module)\s+[^"'\(\)\n;]+\s+from\s+['"]|export\s+(\*|\{|default|function|var|const|let|[_$a-zA-Z\xA0-\uFFFF][_$a-zA-Z0-9\xA0-\uFFFF]*))/;
+
+var ES6AliasRegExp = /(?:^\s*|[}{\(\);,\n]\s*)(export\s*\*\s*from\s*(?:'([^']+)'|"([^"]+)"))/;
+
+module.exports = function (sauce) {
+  return ES6ImportExportRegExp.test(sauce)
+    || ES6AliasRegExp.test(sauce);
+};

data/vendor/node_modules/is-module/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "is-module",
+  "description": "check if a source string is an es6 module",
+  "keywords": ["es6", "module", "modules"],
+  "version": "1.0.0",
+  "author": {
+    "name": "Jonathan Ong",
+    "email": "me@jongleberry.com",
+    "url": "http://jongleberry.com",
+    "twitter": "https://twitter.com/jongleberry"
+  },
+  "license": "MIT",
+  "repository": "component/is-module",
+  "devDependencies": {
+    "mocha": "*"
+  },
+  "scripts": {
+    "test": "mocha --reporter spec --bail"
+  }
+}

data/vendor/node_modules/is-number/index.js

@@ -0,0 +1,19 @@
+/*!
+ * is-number <https://github.com/jonschlinkert/is-number>
+ *
+ * Copyright (c) 2014-2015, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+'use strict';
+
+var typeOf = require('kind-of');
+
+module.exports = function isNumber(num) {
+  var type = typeOf(num);
+  if (type !== 'number' && type !== 'string') {
+    return false;
+  }
+  var n = +num;
+  return (n - n + 1) >= 0 && num !== '';
+};

data/vendor/node_modules/is-number/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "is-number",
+  "description": "Returns true if the value is a number. comprehensive tests.",
+  "version": "2.1.0",
+  "homepage": "https://github.com/jonschlinkert/is-number",
+  "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+  "repository": "jonschlinkert/is-number",
+  "bugs": {
+    "url": "https://github.com/jonschlinkert/is-number/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "dependencies": {
+    "kind-of": "^3.0.2"
+  },
+  "devDependencies": {
+    "benchmarked": "^0.1.3",
+    "chalk": "^0.5.1",
+    "mocha": "*"
+  },
+  "keywords": [
+    "check",
+    "coerce",
+    "coercion",
+    "integer",
+    "is",
+    "is number",
+    "is-number",
+    "istype",
+    "kind of",
+    "math",
+    "number",
+    "test",
+    "type",
+    "typeof",
+    "value"
+  ],
+  "verb": {
+    "related": {
+      "list": [
+        "kind-of",
+        "is-primitive",
+        "even",
+        "odd",
+        "is-even",
+        "is-odd"
+      ]
+    }
+  }
+}

data/vendor/node_modules/is-posix-bracket/index.js

@@ -0,0 +1,10 @@
+/*!
+ * is-posix-bracket <https://github.com/jonschlinkert/is-posix-bracket>
+ *
+ * Copyright (c) 2015-2016, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+module.exports = function isPosixBracket(str) {
+  return typeof str === 'string' && /\[([:.=+])(?:[^\[\]]|)+\1\]/.test(str);
+};

data/vendor/node_modules/is-posix-bracket/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "is-posix-bracket",
+  "description": "Returns true if the given string is a POSIX bracket expression (POSIX character class).",
+  "version": "0.1.1",
+  "homepage": "https://github.com/jonschlinkert/is-posix-bracket",
+  "author": "Jon Schlinkert (https://github.com/jonschlinkert)",
+  "repository": "jonschlinkert/is-posix-bracket",
+  "bugs": {
+    "url": "https://github.com/jonschlinkert/is-posix-bracket/issues"
+  },
+  "license": "MIT",
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "devDependencies": {
+    "gulp-format-md": "^0.1.7",
+    "mocha": "^2.4.5"
+  },
+  "keywords": [
+    "braces",
+    "brackets",
+    "character",
+    "character-class",
+    "class",
+    "expression",
+    "posix",
+    "regex",
+    "regexp",
+    "regular"
+  ],
+  "verb": {
+    "run": true,
+    "toc": false,
+    "layout": "default",
+    "tasks": [
+      "readme"
+    ],
+    "plugins": [
+      "gulp-format-md"
+    ],
+    "related": {
+      "list": [
+        "braces",
+        "expand-brackets",
+        "is-extglob",
+        "is-glob",
+        "micromatch"
+      ]
+    },
+    "reflinks": [
+      "verb"
+    ],
+    "lint": {
+      "reflinks": true
+    }
+  }
+}

data/vendor/node_modules/is-primitive/index.js

@@ -0,0 +1,13 @@
+/*!
+ * is-primitive <https://github.com/jonschlinkert/is-primitive>
+ *
+ * Copyright (c) 2014-2015, Jon Schlinkert.
+ * Licensed under the MIT License.
+ */
+
+'use strict';
+
+// see http://jsperf.com/testing-value-is-primitive/7
+module.exports = function isPrimitive(value) {
+  return value == null || (typeof value !== 'function' && typeof value !== 'object');
+};

data/vendor/node_modules/is-primitive/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "is-primitive",
+  "description": "Returns `true` if the value is a primitive. ",
+  "version": "2.0.0",
+  "homepage": "https://github.com/jonschlinkert/is-primitive",
+  "author": {
+    "name": "Jon Schlinkert",
+    "url": "https://github.com/jonschlinkert"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jonschlinkert/is-primitive.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jonschlinkert/is-primitive/issues"
+  },
+  "license": {
+    "type": "MIT",
+    "url": "https://github.com/jonschlinkert/is-primitive/blob/master/LICENSE"
+  },
+  "files": [
+    "index.js"
+  ],
+  "main": "index.js",
+  "engines": {
+    "node": ">=0.10.0"
+  },
+  "scripts": {
+    "test": "mocha"
+  },
+  "devDependencies": {
+    "mocha": "*",
+    "should": "^4.0.4"
+  },
+  "keywords": [
+    "boolean",
+    "check",
+    "number",
+    "primitive",
+    "string",
+    "symbol",
+    "type",
+    "typeof",
+    "util"
+  ]
+}

data/vendor/node_modules/is-reference/dist/is-reference.es.js

@@ -0,0 +1,26 @@
+function isReference(node, parent) {
+    if (node.type === 'MemberExpression') {
+        return !node.computed && isReference(node.object, node);
+    }
+    if (node.type === 'Identifier') {
+        // the only time we could have an identifier node without a parent is
+        // if it's the entire body of a function without a block statement –
+        // i.e. an arrow function expression like `a => a`
+        if (!parent)
+            return true;
+        // TODO is this right?
+        if (parent.type === 'MemberExpression' || parent.type === 'MethodDefinition') {
+            return parent.computed || node === parent.object;
+        }
+        // disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
+        if (parent.type === 'Property')
+            return parent.computed || node === parent.value;
+        // disregard the `bar` in `export { foo as bar }`
+        if (parent.type === 'ExportSpecifier' && node !== parent.local)
+            return false;
+        return true;
+    }
+    return false;
+}
+
+export default isReference;

data/vendor/node_modules/is-reference/dist/is-reference.js

@@ -0,0 +1,34 @@
+(function (global, factory) {
+	typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :
+	typeof define === 'function' && define.amd ? define(factory) :
+	(global.isReference = factory());
+}(this, (function () { 'use strict';
+
+function isReference(node, parent) {
+    if (node.type === 'MemberExpression') {
+        return !node.computed && isReference(node.object, node);
+    }
+    if (node.type === 'Identifier') {
+        // the only time we could have an identifier node without a parent is
+        // if it's the entire body of a function without a block statement –
+        // i.e. an arrow function expression like `a => a`
+        if (!parent)
+            return true;
+        // TODO is this right?
+        if (parent.type === 'MemberExpression' || parent.type === 'MethodDefinition') {
+            return parent.computed || node === parent.object;
+        }
+        // disregard the `bar` in `{ bar: foo }`, but keep it in `{ [bar]: foo }`
+        if (parent.type === 'Property')
+            return parent.computed || node === parent.value;
+        // disregard the `bar` in `export { foo as bar }`
+        if (parent.type === 'ExportSpecifier' && node !== parent.local)
+            return false;
+        return true;
+    }
+    return false;
+}
+
+return isReference;
+
+})));