summaryrefslogtreecommitdiffstats
path: root/node_modules/esrecurse
diff options
context:
space:
mode:
Diffstat (limited to 'node_modules/esrecurse')
-rw-r--r--node_modules/esrecurse/.babelrc3
-rw-r--r--node_modules/esrecurse/README.md171
-rw-r--r--node_modules/esrecurse/esrecurse.js117
-rw-r--r--node_modules/esrecurse/gulpfile.babel.js92
-rw-r--r--node_modules/esrecurse/node_modules/estraverse/.jshintrc16
-rw-r--r--node_modules/esrecurse/node_modules/estraverse/LICENSE.BSD19
-rw-r--r--node_modules/esrecurse/node_modules/estraverse/README.md153
-rw-r--r--node_modules/esrecurse/node_modules/estraverse/estraverse.js801
-rw-r--r--node_modules/esrecurse/node_modules/estraverse/gulpfile.js70
-rw-r--r--node_modules/esrecurse/node_modules/estraverse/package.json68
-rwxr-xr-xnode_modules/esrecurse/package.json80
11 files changed, 1590 insertions, 0 deletions
diff --git a/node_modules/esrecurse/.babelrc b/node_modules/esrecurse/.babelrc
new file mode 100644
index 0000000..a0765e1
--- /dev/null
+++ b/node_modules/esrecurse/.babelrc
@@ -0,0 +1,3 @@
+{
+ "presets": ["es2015"]
+}
diff --git a/node_modules/esrecurse/README.md b/node_modules/esrecurse/README.md
new file mode 100644
index 0000000..ffea6b4
--- /dev/null
+++ b/node_modules/esrecurse/README.md
@@ -0,0 +1,171 @@
+### Esrecurse [![Build Status](https://travis-ci.org/estools/esrecurse.svg?branch=master)](https://travis-ci.org/estools/esrecurse)
+
+Esrecurse ([esrecurse](https://github.com/estools/esrecurse)) is
+[ECMAScript](https://www.ecma-international.org/publications/standards/Ecma-262.htm)
+recursive traversing functionality.
+
+### Example Usage
+
+The following code will output all variables declared at the root of a file.
+
+```javascript
+esrecurse.visit(ast, {
+ XXXStatement: function (node) {
+ this.visit(node.left);
+ // do something...
+ this.visit(node.right);
+ }
+});
+```
+
+We can use `Visitor` instance.
+
+```javascript
+var visitor = new esrecurse.Visitor({
+ XXXStatement: function (node) {
+ this.visit(node.left);
+ // do something...
+ this.visit(node.right);
+ }
+});
+
+visitor.visit(ast);
+```
+
+We can inherit `Visitor` instance easily.
+
+```javascript
+class Derived extends esrecurse.Visitor {
+ constructor()
+ {
+ super(null);
+ }
+
+ XXXStatement(node) {
+ }
+}
+```
+
+```javascript
+function DerivedVisitor() {
+ esrecurse.Visitor.call(/* this for constructor */ this /* visitor object automatically becomes this. */);
+}
+util.inherits(DerivedVisitor, esrecurse.Visitor);
+DerivedVisitor.prototype.XXXStatement = function (node) {
+ this.visit(node.left);
+ // do something...
+ this.visit(node.right);
+};
+```
+
+And you can invoke default visiting operation inside custom visit operation.
+
+```javascript
+function DerivedVisitor() {
+ esrecurse.Visitor.call(/* this for constructor */ this /* visitor object automatically becomes this. */);
+}
+util.inherits(DerivedVisitor, esrecurse.Visitor);
+DerivedVisitor.prototype.XXXStatement = function (node) {
+ // do something...
+ this.visitChildren(node);
+};
+```
+
+The `childVisitorKeys` option does customize the behaviour of `this.visitChildren(node)`.
+We can use user-defined node types.
+
+```javascript
+// This tree contains a user-defined `TestExpression` node.
+var tree = {
+ type: 'TestExpression',
+
+ // This 'argument' is the property containing the other **node**.
+ argument: {
+ type: 'Literal',
+ value: 20
+ },
+
+ // This 'extended' is the property not containing the other **node**.
+ extended: true
+};
+esrecurse.visit(
+ ast,
+ {
+ Literal: function (node) {
+ // do something...
+ }
+ },
+ {
+ // Extending the existing traversing rules.
+ childVisitorKeys: {
+ // TargetNodeName: [ 'keys', 'containing', 'the', 'other', '**node**' ]
+ TestExpression: ['argument']
+ }
+ }
+);
+```
+
+We can use the `fallback` option as well.
+If the `fallback` option is `"iteration"`, `esrecurse` would visit all enumerable properties of unknown nodes.
+Please note circular references cause the stack overflow. AST might have circular references in additional properties for some purpose (e.g. `node.parent`).
+
+```javascript
+esrecurse.visit(
+ ast,
+ {
+ Literal: function (node) {
+ // do something...
+ }
+ },
+ {
+ fallback: 'iteration'
+ }
+);
+```
+
+If the `fallback` option is a function, `esrecurse` calls this function to determine the enumerable properties of unknown nodes.
+Please note circular references cause the stack overflow. AST might have circular references in additional properties for some purpose (e.g. `node.parent`).
+
+```javascript
+esrecurse.visit(
+ ast,
+ {
+ Literal: function (node) {
+ // do something...
+ }
+ },
+ {
+ fallback: function (node) {
+ return Object.keys(node).filter(function(key) {
+ return key !== 'argument'
+ });
+ }
+ }
+);
+```
+
+### License
+
+Copyright (C) 2014 [Yusuke Suzuki](https://github.com/Constellation)
+ (twitter: [@Constellation](https://twitter.com/Constellation)) and other contributors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/node_modules/esrecurse/esrecurse.js b/node_modules/esrecurse/esrecurse.js
new file mode 100644
index 0000000..15d57df
--- /dev/null
+++ b/node_modules/esrecurse/esrecurse.js
@@ -0,0 +1,117 @@
+/*
+ Copyright (C) 2014 Yusuke Suzuki <utatane.tea@gmail.com>
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+(function () {
+ 'use strict';
+
+ var estraverse = require('estraverse');
+
+ function isNode(node) {
+ if (node == null) {
+ return false;
+ }
+ return typeof node === 'object' && typeof node.type === 'string';
+ }
+
+ function isProperty(nodeType, key) {
+ return (nodeType === estraverse.Syntax.ObjectExpression || nodeType === estraverse.Syntax.ObjectPattern) && key === 'properties';
+ }
+
+ function Visitor(visitor, options) {
+ options = options || {};
+
+ this.__visitor = visitor || this;
+ this.__childVisitorKeys = options.childVisitorKeys
+ ? Object.assign({}, estraverse.VisitorKeys, options.childVisitorKeys)
+ : estraverse.VisitorKeys;
+ if (options.fallback === 'iteration') {
+ this.__fallback = Object.keys;
+ } else if (typeof options.fallback === 'function') {
+ this.__fallback = options.fallback;
+ }
+ }
+
+ /* Default method for visiting children.
+ * When you need to call default visiting operation inside custom visiting
+ * operation, you can use it with `this.visitChildren(node)`.
+ */
+ Visitor.prototype.visitChildren = function (node) {
+ var type, children, i, iz, j, jz, child;
+
+ if (node == null) {
+ return;
+ }
+
+ type = node.type || estraverse.Syntax.Property;
+
+ children = this.__childVisitorKeys[type];
+ if (!children) {
+ if (this.__fallback) {
+ children = this.__fallback(node);
+ } else {
+ throw new Error('Unknown node type ' + type + '.');
+ }
+ }
+
+ for (i = 0, iz = children.length; i < iz; ++i) {
+ child = node[children[i]];
+ if (child) {
+ if (Array.isArray(child)) {
+ for (j = 0, jz = child.length; j < jz; ++j) {
+ if (child[j]) {
+ if (isNode(child[j]) || isProperty(type, children[i])) {
+ this.visit(child[j]);
+ }
+ }
+ }
+ } else if (isNode(child)) {
+ this.visit(child);
+ }
+ }
+ }
+ };
+
+ /* Dispatching node. */
+ Visitor.prototype.visit = function (node) {
+ var type;
+
+ if (node == null) {
+ return;
+ }
+
+ type = node.type || estraverse.Syntax.Property;
+ if (this.__visitor[type]) {
+ this.__visitor[type].call(this, node);
+ return;
+ }
+ this.visitChildren(node);
+ };
+
+ exports.version = require('./package.json').version;
+ exports.Visitor = Visitor;
+ exports.visit = function (node, visitor, options) {
+ var v = new Visitor(visitor, options);
+ v.visit(node);
+ };
+}());
+/* vim: set sw=4 ts=4 et tw=80 : */
diff --git a/node_modules/esrecurse/gulpfile.babel.js b/node_modules/esrecurse/gulpfile.babel.js
new file mode 100644
index 0000000..aa881c9
--- /dev/null
+++ b/node_modules/esrecurse/gulpfile.babel.js
@@ -0,0 +1,92 @@
+// Copyright (C) 2014 Yusuke Suzuki <utatane.tea@gmail.com>
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+// * Redistributions in binary form must reproduce the above copyright
+// notice, this list of conditions and the following disclaimer in the
+// documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+// ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+import gulp from 'gulp';
+import mocha from 'gulp-mocha';
+import eslint from 'gulp-eslint';
+import minimist from 'minimist';
+import git from 'gulp-git';
+import bump from 'gulp-bump';
+import filter from 'gulp-filter';
+import tagVersion from 'gulp-tag-version';
+import 'babel-register';
+
+const SOURCE = [
+ '*.js'
+];
+
+let ESLINT_OPTION = {
+ parser: 'babel-eslint',
+ parserOptions: {
+ 'sourceType': 'module'
+ },
+ rules: {
+ 'quotes': 0,
+ 'eqeqeq': 0,
+ 'no-use-before-define': 0,
+ 'no-shadow': 0,
+ 'no-new': 0,
+ 'no-underscore-dangle': 0,
+ 'no-multi-spaces': 0,
+ 'no-native-reassign': 0,
+ 'no-loop-func': 0
+ },
+ env: {
+ 'node': true
+ }
+};
+
+gulp.task('test', function() {
+ let options = minimist(process.argv.slice(2), {
+ string: 'test',
+ default: {
+ test: 'test/*.js'
+ }
+ }
+ );
+ return gulp.src(options.test).pipe(mocha({reporter: 'spec'}));
+});
+
+gulp.task('lint', () =>
+ gulp.src(SOURCE)
+ .pipe(eslint(ESLINT_OPTION))
+ .pipe(eslint.formatEach('stylish', process.stderr))
+ .pipe(eslint.failOnError())
+);
+
+let inc = importance =>
+ gulp.src(['./package.json'])
+ .pipe(bump({type: importance}))
+ .pipe(gulp.dest('./'))
+ .pipe(git.commit('Bumps package version'))
+ .pipe(filter('package.json'))
+ .pipe(tagVersion({
+ prefix: ''
+ }))
+;
+
+gulp.task('travis', [ 'lint', 'test' ]);
+gulp.task('default', [ 'travis' ]);
+
+gulp.task('patch', [ ], () => inc('patch'));
+gulp.task('minor', [ ], () => inc('minor'));
+gulp.task('major', [ ], () => inc('major'));
diff --git a/node_modules/esrecurse/node_modules/estraverse/.jshintrc b/node_modules/esrecurse/node_modules/estraverse/.jshintrc
new file mode 100644
index 0000000..f642dae
--- /dev/null
+++ b/node_modules/esrecurse/node_modules/estraverse/.jshintrc
@@ -0,0 +1,16 @@
+{
+ "curly": true,
+ "eqeqeq": true,
+ "immed": true,
+ "eqnull": true,
+ "latedef": true,
+ "noarg": true,
+ "noempty": true,
+ "quotmark": "single",
+ "undef": true,
+ "unused": true,
+ "strict": true,
+ "trailing": true,
+
+ "node": true
+}
diff --git a/node_modules/esrecurse/node_modules/estraverse/LICENSE.BSD b/node_modules/esrecurse/node_modules/estraverse/LICENSE.BSD
new file mode 100644
index 0000000..3e580c3
--- /dev/null
+++ b/node_modules/esrecurse/node_modules/estraverse/LICENSE.BSD
@@ -0,0 +1,19 @@
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/node_modules/esrecurse/node_modules/estraverse/README.md b/node_modules/esrecurse/node_modules/estraverse/README.md
new file mode 100644
index 0000000..ccd3377
--- /dev/null
+++ b/node_modules/esrecurse/node_modules/estraverse/README.md
@@ -0,0 +1,153 @@
+### Estraverse [![Build Status](https://secure.travis-ci.org/estools/estraverse.svg)](http://travis-ci.org/estools/estraverse)
+
+Estraverse ([estraverse](http://github.com/estools/estraverse)) is
+[ECMAScript](http://www.ecma-international.org/publications/standards/Ecma-262.htm)
+traversal functions from [esmangle project](http://github.com/estools/esmangle).
+
+### Documentation
+
+You can find usage docs at [wiki page](https://github.com/estools/estraverse/wiki/Usage).
+
+### Example Usage
+
+The following code will output all variables declared at the root of a file.
+
+```javascript
+estraverse.traverse(ast, {
+ enter: function (node, parent) {
+ if (node.type == 'FunctionExpression' || node.type == 'FunctionDeclaration')
+ return estraverse.VisitorOption.Skip;
+ },
+ leave: function (node, parent) {
+ if (node.type == 'VariableDeclarator')
+ console.log(node.id.name);
+ }
+});
+```
+
+We can use `this.skip`, `this.remove` and `this.break` functions instead of using Skip, Remove and Break.
+
+```javascript
+estraverse.traverse(ast, {
+ enter: function (node) {
+ this.break();
+ }
+});
+```
+
+And estraverse provides `estraverse.replace` function. When returning node from `enter`/`leave`, current node is replaced with it.
+
+```javascript
+result = estraverse.replace(tree, {
+ enter: function (node) {
+ // Replace it with replaced.
+ if (node.type === 'Literal')
+ return replaced;
+ }
+});
+```
+
+By passing `visitor.keys` mapping, we can extend estraverse traversing functionality.
+
+```javascript
+// This tree contains a user-defined `TestExpression` node.
+var tree = {
+ type: 'TestExpression',
+
+ // This 'argument' is the property containing the other **node**.
+ argument: {
+ type: 'Literal',
+ value: 20
+ },
+
+ // This 'extended' is the property not containing the other **node**.
+ extended: true
+};
+estraverse.traverse(tree, {
+ enter: function (node) { },
+
+ // Extending the existing traversing rules.
+ keys: {
+ // TargetNodeName: [ 'keys', 'containing', 'the', 'other', '**node**' ]
+ TestExpression: ['argument']
+ }
+});
+```
+
+By passing `visitor.fallback` option, we can control the behavior when encountering unknown nodes.
+
+```javascript
+// This tree contains a user-defined `TestExpression` node.
+var tree = {
+ type: 'TestExpression',
+
+ // This 'argument' is the property containing the other **node**.
+ argument: {
+ type: 'Literal',
+ value: 20
+ },
+
+ // This 'extended' is the property not containing the other **node**.
+ extended: true
+};
+estraverse.traverse(tree, {
+ enter: function (node) { },
+
+ // Iterating the child **nodes** of unknown nodes.
+ fallback: 'iteration'
+});
+```
+
+When `visitor.fallback` is a function, we can determine which keys to visit on each node.
+
+```javascript
+// This tree contains a user-defined `TestExpression` node.
+var tree = {
+ type: 'TestExpression',
+
+ // This 'argument' is the property containing the other **node**.
+ argument: {
+ type: 'Literal',
+ value: 20
+ },
+
+ // This 'extended' is the property not containing the other **node**.
+ extended: true
+};
+estraverse.traverse(tree, {
+ enter: function (node) { },
+
+ // Skip the `argument` property of each node
+ fallback: function(node) {
+ return Object.keys(node).filter(function(key) {
+ return key !== 'argument';
+ });
+ }
+});
+```
+
+### License
+
+Copyright (C) 2012-2016 [Yusuke Suzuki](http://github.com/Constellation)
+ (twitter: [@Constellation](http://twitter.com/Constellation)) and other contributors.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/node_modules/esrecurse/node_modules/estraverse/estraverse.js b/node_modules/esrecurse/node_modules/estraverse/estraverse.js
new file mode 100644
index 0000000..93225bb
--- /dev/null
+++ b/node_modules/esrecurse/node_modules/estraverse/estraverse.js
@@ -0,0 +1,801 @@
+/*
+ Copyright (C) 2012-2013 Yusuke Suzuki <utatane.tea@gmail.com>
+ Copyright (C) 2012 Ariya Hidayat <ariya.hidayat@gmail.com>
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+/*jslint vars:false, bitwise:true*/
+/*jshint indent:4*/
+/*global exports:true*/
+(function clone(exports) {
+ 'use strict';
+
+ var Syntax,
+ VisitorOption,
+ VisitorKeys,
+ BREAK,
+ SKIP,
+ REMOVE;
+
+ function deepCopy(obj) {
+ var ret = {}, key, val;
+ for (key in obj) {
+ if (obj.hasOwnProperty(key)) {
+ val = obj[key];
+ if (typeof val === 'object' && val !== null) {
+ ret[key] = deepCopy(val);
+ } else {
+ ret[key] = val;
+ }
+ }
+ }
+ return ret;
+ }
+
+ // based on LLVM libc++ upper_bound / lower_bound
+ // MIT License
+
+ function upperBound(array, func) {
+ var diff, len, i, current;
+
+ len = array.length;
+ i = 0;
+
+ while (len) {
+ diff = len >>> 1;
+ current = i + diff;
+ if (func(array[current])) {
+ len = diff;
+ } else {
+ i = current + 1;
+ len -= diff + 1;
+ }
+ }
+ return i;
+ }
+
+ Syntax = {
+ AssignmentExpression: 'AssignmentExpression',
+ AssignmentPattern: 'AssignmentPattern',
+ ArrayExpression: 'ArrayExpression',
+ ArrayPattern: 'ArrayPattern',
+ ArrowFunctionExpression: 'ArrowFunctionExpression',
+ AwaitExpression: 'AwaitExpression', // CAUTION: It's deferred to ES7.
+ BlockStatement: 'BlockStatement',
+ BinaryExpression: 'BinaryExpression',
+ BreakStatement: 'BreakStatement',
+ CallExpression: 'CallExpression',
+ CatchClause: 'CatchClause',
+ ChainExpression: 'ChainExpression',
+ ClassBody: 'ClassBody',
+ ClassDeclaration: 'ClassDeclaration',
+ ClassExpression: 'ClassExpression',
+ ComprehensionBlock: 'ComprehensionBlock', // CAUTION: It's deferred to ES7.
+ ComprehensionExpression: 'ComprehensionExpression', // CAUTION: It's deferred to ES7.
+ ConditionalExpression: 'ConditionalExpression',
+ ContinueStatement: 'ContinueStatement',
+ DebuggerStatement: 'DebuggerStatement',
+ DirectiveStatement: 'DirectiveStatement',
+ DoWhileStatement: 'DoWhileStatement',
+ EmptyStatement: 'EmptyStatement',
+ ExportAllDeclaration: 'ExportAllDeclaration',
+ ExportDefaultDeclaration: 'ExportDefaultDeclaration',
+ ExportNamedDeclaration: 'ExportNamedDeclaration',
+ ExportSpecifier: 'ExportSpecifier',
+ ExpressionStatement: 'ExpressionStatement',
+ ForStatement: 'ForStatement',
+ ForInStatement: 'ForInStatement',
+ ForOfStatement: 'ForOfStatement',
+ FunctionDeclaration: 'FunctionDeclaration',
+ FunctionExpression: 'FunctionExpression',
+ GeneratorExpression: 'GeneratorExpression', // CAUTION: It's deferred to ES7.
+ Identifier: 'Identifier',
+ IfStatement: 'IfStatement',
+ ImportExpression: 'ImportExpression',
+ ImportDeclaration: 'ImportDeclaration',
+ ImportDefaultSpecifier: 'ImportDefaultSpecifier',
+ ImportNamespaceSpecifier: 'ImportNamespaceSpecifier',
+ ImportSpecifier: 'ImportSpecifier',
+ Literal: 'Literal',
+ LabeledStatement: 'LabeledStatement',
+ LogicalExpression: 'LogicalExpression',
+ MemberExpression: 'MemberExpression',
+ MetaProperty: 'MetaProperty',
+ MethodDefinition: 'MethodDefinition',
+ ModuleSpecifier: 'ModuleSpecifier',
+ NewExpression: 'NewExpression',
+ ObjectExpression: 'ObjectExpression',
+ ObjectPattern: 'ObjectPattern',
+ Program: 'Program',
+ Property: 'Property',
+ RestElement: 'RestElement',
+ ReturnStatement: 'ReturnStatement',
+ SequenceExpression: 'SequenceExpression',
+ SpreadElement: 'SpreadElement',
+ Super: 'Super',
+ SwitchStatement: 'SwitchStatement',
+ SwitchCase: 'SwitchCase',
+ TaggedTemplateExpression: 'TaggedTemplateExpression',
+ TemplateElement: 'TemplateElement',
+ TemplateLiteral: 'TemplateLiteral',
+ ThisExpression: 'ThisExpression',
+ ThrowStatement: 'ThrowStatement',
+ TryStatement: 'TryStatement',
+ UnaryExpression: 'UnaryExpression',
+ UpdateExpression: 'UpdateExpression',
+ VariableDeclaration: 'VariableDeclaration',
+ VariableDeclarator: 'VariableDeclarator',
+ WhileStatement: 'WhileStatement',
+ WithStatement: 'WithStatement',
+ YieldExpression: 'YieldExpression'
+ };
+
+ VisitorKeys = {
+ AssignmentExpression: ['left', 'right'],
+ AssignmentPattern: ['left', 'right'],
+ ArrayExpression: ['elements'],
+ ArrayPattern: ['elements'],
+ ArrowFunctionExpression: ['params', 'body'],
+ AwaitExpression: ['argument'], // CAUTION: It's deferred to ES7.
+ BlockStatement: ['body'],
+ BinaryExpression: ['left', 'right'],
+ BreakStatement: ['label'],
+ CallExpression: ['callee', 'arguments'],
+ CatchClause: ['param', 'body'],
+ ChainExpression: ['expression'],
+ ClassBody: ['body'],
+ ClassDeclaration: ['id', 'superClass', 'body'],
+ ClassExpression: ['id', 'superClass', 'body'],
+ ComprehensionBlock: ['left', 'right'], // CAUTION: It's deferred to ES7.
+ ComprehensionExpression: ['blocks', 'filter', 'body'], // CAUTION: It's deferred to ES7.
+ ConditionalExpression: ['test', 'consequent', 'alternate'],
+ ContinueStatement: ['label'],
+ DebuggerStatement: [],
+ DirectiveStatement: [],
+ DoWhileStatement: ['body', 'test'],
+ EmptyStatement: [],
+ ExportAllDeclaration: ['source'],
+ ExportDefaultDeclaration: ['declaration'],
+ ExportNamedDeclaration: ['declaration', 'specifiers', 'source'],
+ ExportSpecifier: ['exported', 'local'],
+ ExpressionStatement: ['expression'],
+ ForStatement: ['init', 'test', 'update', 'body'],
+ ForInStatement: ['left', 'right', 'body'],
+ ForOfStatement: ['left', 'right', 'body'],
+ FunctionDeclaration: ['id', 'params', 'body'],
+ FunctionExpression: ['id', 'params', 'body'],
+ GeneratorExpression: ['blocks', 'filter', 'body'], // CAUTION: It's deferred to ES7.
+ Identifier: [],
+ IfStatement: ['test', 'consequent', 'alternate'],
+ ImportExpression: ['source'],
+ ImportDeclaration: ['specifiers', 'source'],
+ ImportDefaultSpecifier: ['local'],
+ ImportNamespaceSpecifier: ['local'],
+ ImportSpecifier: ['imported', 'local'],
+ Literal: [],
+ LabeledStatement: ['label', 'body'],
+ LogicalExpression: ['left', 'right'],
+ MemberExpression: ['object', 'property'],
+ MetaProperty: ['meta', 'property'],
+ MethodDefinition: ['key', 'value'],
+ ModuleSpecifier: [],
+ NewExpression: ['callee', 'arguments'],
+ ObjectExpression: ['properties'],
+ ObjectPattern: ['properties'],
+ Program: ['body'],
+ Property: ['key', 'value'],
+ RestElement: [ 'argument' ],
+ ReturnStatement: ['argument'],
+ SequenceExpression: ['expressions'],
+ SpreadElement: ['argument'],
+ Super: [],
+ SwitchStatement: ['discriminant', 'cases'],
+ SwitchCase: ['test', 'consequent'],
+ TaggedTemplateExpression: ['tag', 'quasi'],
+ TemplateElement: [],
+ TemplateLiteral: ['quasis', 'expressions'],
+ ThisExpression: [],
+ ThrowStatement: ['argument'],
+ TryStatement: ['block', 'handler', 'finalizer'],
+ UnaryExpression: ['argument'],
+ UpdateExpression: ['argument'],
+ VariableDeclaration: ['declarations'],
+ VariableDeclarator: ['id', 'init'],
+ WhileStatement: ['test', 'body'],
+ WithStatement: ['object', 'body'],
+ YieldExpression: ['argument']
+ };
+
+ // unique id
+ BREAK = {};
+ SKIP = {};
+ REMOVE = {};
+
+ VisitorOption = {
+ Break: BREAK,
+ Skip: SKIP,
+ Remove: REMOVE
+ };
+
+ function Reference(parent, key) {
+ this.parent = parent;
+ this.key = key;
+ }
+
+ Reference.prototype.replace = function replace(node) {
+ this.parent[this.key] = node;
+ };
+
+ Reference.prototype.remove = function remove() {
+ if (Array.isArray(this.parent)) {
+ this.parent.splice(this.key, 1);
+ return true;
+ } else {
+ this.replace(null);
+ return false;
+ }
+ };
+
+ function Element(node, path, wrap, ref) {
+ this.node = node;
+ this.path = path;
+ this.wrap = wrap;
+ this.ref = ref;
+ }
+
+ function Controller() { }
+
+ // API:
+ // return property path array from root to current node
+ Controller.prototype.path = function path() {
+ var i, iz, j, jz, result, element;
+
+ function addToPath(result, path) {
+ if (Array.isArray(path)) {
+ for (j = 0, jz = path.length; j < jz; ++j) {
+ result.push(path[j]);
+ }
+ } else {
+ result.push(path);
+ }
+ }
+
+ // root node
+ if (!this.__current.path) {
+ return null;
+ }
+
+ // first node is sentinel, second node is root element
+ result = [];
+ for (i = 2, iz = this.__leavelist.length; i < iz; ++i) {
+ element = this.__leavelist[i];
+ addToPath(result, element.path);
+ }
+ addToPath(result, this.__current.path);
+ return result;
+ };
+
+ // API:
+ // return type of current node
+ Controller.prototype.type = function () {
+ var node = this.current();
+ return node.type || this.__current.wrap;
+ };
+
+ // API:
+ // return array of parent elements
+ Controller.prototype.parents = function parents() {
+ var i, iz, result;
+
+ // first node is sentinel
+ result = [];
+ for (i = 1, iz = this.__leavelist.length; i < iz; ++i) {
+ result.push(this.__leavelist[i].node);
+ }
+
+ return result;
+ };
+
+ // API:
+ // return current node
+ Controller.prototype.current = function current() {
+ return this.__current.node;
+ };
+
+ Controller.prototype.__execute = function __execute(callback, element) {
+ var previous, result;
+
+ result = undefined;
+
+ previous = this.__current;
+ this.__current = element;
+ this.__state = null;
+ if (callback) {
+ result = callback.call(this, element.node, this.__leavelist[this.__leavelist.length - 1].node);
+ }
+ this.__current = previous;
+
+ return result;
+ };
+
+ // API:
+ // notify control skip / break
+ Controller.prototype.notify = function notify(flag) {
+ this.__state = flag;
+ };
+
+ // API:
+ // skip child nodes of current node
+ Controller.prototype.skip = function () {
+ this.notify(SKIP);
+ };
+
+ // API:
+ // break traversals
+ Controller.prototype['break'] = function () {
+ this.notify(BREAK);
+ };
+
+ // API:
+ // remove node
+ Controller.prototype.remove = function () {
+ this.notify(REMOVE);
+ };
+
+ Controller.prototype.__initialize = function(root, visitor) {
+ this.visitor = visitor;
+ this.root = root;
+ this.__worklist = [];
+ this.__leavelist = [];
+ this.__current = null;
+ this.__state = null;
+ this.__fallback = null;
+ if (visitor.fallback === 'iteration') {
+ this.__fallback = Object.keys;
+ } else if (typeof visitor.fallback === 'function') {
+ this.__fallback = visitor.fallback;
+ }
+
+ this.__keys = VisitorKeys;
+ if (visitor.keys) {
+ this.__keys = Object.assign(Object.create(this.__keys), visitor.keys);
+ }
+ };
+
+ function isNode(node) {
+ if (node == null) {
+ return false;
+ }
+ return typeof node === 'object' && typeof node.type === 'string';
+ }
+
+ function isProperty(nodeType, key) {
+ return (nodeType === Syntax.ObjectExpression || nodeType === Syntax.ObjectPattern) && 'properties' === key;
+ }
+
+ function candidateExistsInLeaveList(leavelist, candidate) {
+ for (var i = leavelist.length - 1; i >= 0; --i) {
+ if (leavelist[i].node === candidate) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ Controller.prototype.traverse = function traverse(root, visitor) {
+ var worklist,
+ leavelist,
+ element,
+ node,
+ nodeType,
+ ret,
+ key,
+ current,
+ current2,
+ candidates,
+ candidate,
+ sentinel;
+
+ this.__initialize(root, visitor);
+
+ sentinel = {};
+
+ // reference
+ worklist = this.__worklist;
+ leavelist = this.__leavelist;
+
+ // initialize
+ worklist.push(new Element(root, null, null, null));
+ leavelist.push(new Element(null, null, null, null));
+
+ while (worklist.length) {
+ element = worklist.pop();
+
+ if (element === sentinel) {
+ element = leavelist.pop();
+
+ ret = this.__execute(visitor.leave, element);
+
+ if (this.__state === BREAK || ret === BREAK) {
+ return;
+ }
+ continue;
+ }
+
+ if (element.node) {
+
+ ret = this.__execute(visitor.enter, element);
+
+ if (this.__state === BREAK || ret === BREAK) {
+ return;
+ }
+
+ worklist.push(sentinel);
+ leavelist.push(element);
+
+ if (this.__state === SKIP || ret === SKIP) {
+ continue;
+ }
+
+ node = element.node;
+ nodeType = node.type || element.wrap;
+ candidates = this.__keys[nodeType];
+ if (!candidates) {
+ if (this.__fallback) {
+ candidates = this.__fallback(node);
+ } else {
+ throw new Error('Unknown node type ' + nodeType + '.');
+ }
+ }
+
+ current = candidates.length;
+ while ((current -= 1) >= 0) {
+ key = candidates[current];
+ candidate = node[key];
+ if (!candidate) {
+ continue;
+ }
+
+ if (Array.isArray(candidate)) {
+ current2 = candidate.length;
+ while ((current2 -= 1) >= 0) {
+ if (!candidate[current2]) {
+ continue;
+ }
+
+ if (candidateExistsInLeaveList(leavelist, candidate[current2])) {
+ continue;
+ }
+
+ if (isProperty(nodeType, candidates[current])) {
+ element = new Element(candidate[current2], [key, current2], 'Property', null);
+ } else if (isNode(candidate[current2])) {
+ element = new Element(candidate[current2], [key, current2], null, null);
+ } else {
+ continue;
+ }
+ worklist.push(element);
+ }
+ } else if (isNode(candidate)) {
+ if (candidateExistsInLeaveList(leavelist, candidate)) {
+ continue;
+ }
+
+ worklist.push(new Element(candidate, key, null, null));
+ }
+ }
+ }
+ }
+ };
+
+ Controller.prototype.replace = function replace(root, visitor) {
+ var worklist,
+ leavelist,
+ node,
+ nodeType,
+ target,
+ element,
+ current,
+ current2,
+ candidates,
+ candidate,
+ sentinel,
+ outer,
+ key;
+
+ function removeElem(element) {
+ var i,
+ key,
+ nextElem,
+ parent;
+
+ if (element.ref.remove()) {
+ // When the reference is an element of an array.
+ key = element.ref.key;
+ parent = element.ref.parent;
+
+ // If removed from array, then decrease following items' keys.
+ i = worklist.length;
+ while (i--) {
+ nextElem = worklist[i];
+ if (nextElem.ref && nextElem.ref.parent === parent) {
+ if (nextElem.ref.key < key) {
+ break;
+ }
+ --nextElem.ref.key;
+ }
+ }
+ }
+ }
+
+ this.__initialize(root, visitor);
+
+ sentinel = {};
+
+ // reference
+ worklist = this.__worklist;
+ leavelist = this.__leavelist;
+
+ // initialize
+ outer = {
+ root: root
+ };
+ element = new Element(root, null, null, new Reference(outer, 'root'));
+ worklist.push(element);
+ leavelist.push(element);
+
+ while (worklist.length) {
+ element = worklist.pop();
+
+ if (element === sentinel) {
+ element = leavelist.pop();
+
+ target = this.__execute(visitor.leave, element);
+
+ // node may be replaced with null,
+ // so distinguish between undefined and null in this place
+ if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
+ // replace
+ element.ref.replace(target);
+ }
+
+ if (this.__state === REMOVE || target === REMOVE) {
+ removeElem(element);
+ }
+
+ if (this.__state === BREAK || target === BREAK) {
+ return outer.root;
+ }
+ continue;
+ }
+
+ target = this.__execute(visitor.enter, element);
+
+ // node may be replaced with null,
+ // so distinguish between undefined and null in this place
+ if (target !== undefined && target !== BREAK && target !== SKIP && target !== REMOVE) {
+ // replace
+ element.ref.replace(target);
+ element.node = target;
+ }
+
+ if (this.__state === REMOVE || target === REMOVE) {
+ removeElem(element);
+ element.node = null;
+ }
+
+ if (this.__state === BREAK || target === BREAK) {
+ return outer.root;
+ }
+
+ // node may be null
+ node = element.node;
+ if (!node) {
+ continue;
+ }
+
+ worklist.push(sentinel);
+ leavelist.push(element);
+
+ if (this.__state === SKIP || target === SKIP) {
+ continue;
+ }
+
+ nodeType = node.type || element.wrap;
+ candidates = this.__keys[nodeType];
+ if (!candidates) {
+ if (this.__fallback) {
+ candidates = this.__fallback(node);
+ } else {
+ throw new Error('Unknown node type ' + nodeType + '.');
+ }
+ }
+
+ current = candidates.length;
+ while ((current -= 1) >= 0) {
+ key = candidates[current];
+ candidate = node[key];
+ if (!candidate) {
+ continue;
+ }
+
+ if (Array.isArray(candidate)) {
+ current2 = candidate.length;
+ while ((current2 -= 1) >= 0) {
+ if (!candidate[current2]) {
+ continue;
+ }
+ if (isProperty(nodeType, candidates[current])) {
+ element = new Element(candidate[current2], [key, current2], 'Property', new Reference(candidate, current2));
+ } else if (isNode(candidate[current2])) {
+ element = new Element(candidate[current2], [key, current2], null, new Reference(candidate, current2));
+ } else {
+ continue;
+ }
+ worklist.push(element);
+ }
+ } else if (isNode(candidate)) {
+ worklist.push(new Element(candidate, key, null, new Reference(node, key)));
+ }
+ }
+ }
+
+ return outer.root;
+ };
+
+ function traverse(root, visitor) {
+ var controller = new Controller();
+ return controller.traverse(root, visitor);
+ }
+
+ function replace(root, visitor) {
+ var controller = new Controller();
+ return controller.replace(root, visitor);
+ }
+
+ function extendCommentRange(comment, tokens) {
+ var target;
+
+ target = upperBound(tokens, function search(token) {
+ return token.range[0] > comment.range[0];
+ });
+
+ comment.extendedRange = [comment.range[0], comment.range[1]];
+
+ if (target !== tokens.length) {
+ comment.extendedRange[1] = tokens[target].range[0];
+ }
+
+ target -= 1;
+ if (target >= 0) {
+ comment.extendedRange[0] = tokens[target].range[1];
+ }
+
+ return comment;
+ }
+
+ function attachComments(tree, providedComments, tokens) {
+ // At first, we should calculate extended comment ranges.
+ var comments = [], comment, len, i, cursor;
+
+ if (!tree.range) {
+ throw new Error('attachComments needs range information');
+ }
+
+ // tokens array is empty, we attach comments to tree as 'leadingComments'
+ if (!tokens.length) {
+ if (providedComments.length) {
+ for (i = 0, len = providedComments.length; i < len; i += 1) {
+ comment = deepCopy(providedComments[i]);
+ comment.extendedRange = [0, tree.range[0]];
+ comments.push(comment);
+ }
+ tree.leadingComments = comments;
+ }
+ return tree;
+ }
+
+ for (i = 0, len = providedComments.length; i < len; i += 1) {
+ comments.push(extendCommentRange(deepCopy(providedComments[i]), tokens));
+ }
+
+ // This is based on John Freeman's implementation.
+ cursor = 0;
+ traverse(tree, {
+ enter: function (node) {
+ var comment;
+
+ while (cursor < comments.length) {
+ comment = comments[cursor];
+ if (comment.extendedRange[1] > node.range[0]) {
+ break;
+ }
+
+ if (comment.extendedRange[1] === node.range[0]) {
+ if (!node.leadingComments) {
+ node.leadingComments = [];
+ }
+ node.leadingComments.push(comment);
+ comments.splice(cursor, 1);
+ } else {
+ cursor += 1;
+ }
+ }
+
+ // already out of owned node
+ if (cursor === comments.length) {
+ return VisitorOption.Break;
+ }
+
+ if (comments[cursor].extendedRange[0] > node.range[1]) {
+ return VisitorOption.Skip;
+ }
+ }
+ });
+
+ cursor = 0;
+ traverse(tree, {
+ leave: function (node) {
+ var comment;
+
+ while (cursor < comments.length) {
+ comment = comments[cursor];
+ if (node.range[1] < comment.extendedRange[0]) {
+ break;
+ }
+
+ if (node.range[1] === comment.extendedRange[0]) {
+ if (!node.trailingComments) {
+ node.trailingComments = [];
+ }
+ node.trailingComments.push(comment);
+ comments.splice(cursor, 1);
+ } else {
+ cursor += 1;
+ }
+ }
+
+ // already out of owned node
+ if (cursor === comments.length) {
+ return VisitorOption.Break;
+ }
+
+ if (comments[cursor].extendedRange[0] > node.range[1]) {
+ return VisitorOption.Skip;
+ }
+ }
+ });
+
+ return tree;
+ }
+
+ exports.Syntax = Syntax;
+ exports.traverse = traverse;
+ exports.replace = replace;
+ exports.attachComments = attachComments;
+ exports.VisitorKeys = VisitorKeys;
+ exports.VisitorOption = VisitorOption;
+ exports.Controller = Controller;
+ exports.cloneEnvironment = function () { return clone({}); };
+
+ return exports;
+}(exports));
+/* vim: set sw=4 ts=4 et tw=80 : */
diff --git a/node_modules/esrecurse/node_modules/estraverse/gulpfile.js b/node_modules/esrecurse/node_modules/estraverse/gulpfile.js
new file mode 100644
index 0000000..8772bbc
--- /dev/null
+++ b/node_modules/esrecurse/node_modules/estraverse/gulpfile.js
@@ -0,0 +1,70 @@
+/*
+ Copyright (C) 2014 Yusuke Suzuki <utatane.tea@gmail.com>
+
+ Redistribution and use in source and binary forms, with or without
+ modification, are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 'AS IS'
+ AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ ARE DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+'use strict';
+
+var gulp = require('gulp'),
+ git = require('gulp-git'),
+ bump = require('gulp-bump'),
+ filter = require('gulp-filter'),
+ tagVersion = require('gulp-tag-version');
+
+var TEST = [ 'test/*.js' ];
+var POWERED = [ 'powered-test/*.js' ];
+var SOURCE = [ 'src/**/*.js' ];
+
+/**
+ * Bumping version number and tagging the repository with it.
+ * Please read http://semver.org/
+ *
+ * You can use the commands
+ *
+ * gulp patch # makes v0.1.0 -> v0.1.1
+ * gulp feature # makes v0.1.1 -> v0.2.0
+ * gulp release # makes v0.2.1 -> v1.0.0
+ *
+ * To bump the version numbers accordingly after you did a patch,
+ * introduced a feature or made a backwards-incompatible release.
+ */
+
+function inc(importance) {
+ // get all the files to bump version in
+ return gulp.src(['./package.json'])
+ // bump the version number in those files
+ .pipe(bump({type: importance}))
+ // save it back to filesystem
+ .pipe(gulp.dest('./'))
+ // commit the changed version number
+ .pipe(git.commit('Bumps package version'))
+ // read only one file to get the version number
+ .pipe(filter('package.json'))
+ // **tag it in the repository**
+ .pipe(tagVersion({
+ prefix: ''
+ }));
+}
+
+gulp.task('patch', [ ], function () { return inc('patch'); })
+gulp.task('minor', [ ], function () { return inc('minor'); })
+gulp.task('major', [ ], function () { return inc('major'); })
diff --git a/node_modules/esrecurse/node_modules/estraverse/package.json b/node_modules/esrecurse/node_modules/estraverse/package.json
new file mode 100644
index 0000000..2bb15cf
--- /dev/null
+++ b/node_modules/esrecurse/node_modules/estraverse/package.json
@@ -0,0 +1,68 @@
+{
+ "_from": "estraverse@^5.2.0",
+ "_id": "estraverse@5.2.0",
+ "_inBundle": false,
+ "_integrity": "sha512-BxbNGGNm0RyRYvUdHpIwv9IWzeM9XClbOxwoATuFdOE7ZE6wHL+HQ5T8hoPM+zHvmKzzsEqhgy0GrQ5X13afiQ==",
+ "_location": "/esrecurse/estraverse",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "estraverse@^5.2.0",
+ "name": "estraverse",
+ "escapedName": "estraverse",
+ "rawSpec": "^5.2.0",
+ "saveSpec": null,
+ "fetchSpec": "^5.2.0"
+ },
+ "_requiredBy": [
+ "/esrecurse"
+ ],
+ "_resolved": "https://registry.npmjs.org/estraverse/-/estraverse-5.2.0.tgz",
+ "_shasum": "307df42547e6cc7324d3cf03c155d5cdb8c53880",
+ "_spec": "estraverse@^5.2.0",
+ "_where": "/home/pruss/Dev/3-minute-website/node_modules/esrecurse",
+ "bugs": {
+ "url": "https://github.com/estools/estraverse/issues"
+ },
+ "bundleDependencies": false,
+ "deprecated": false,
+ "description": "ECMAScript JS AST traversal functions",
+ "devDependencies": {
+ "babel-preset-env": "^1.6.1",
+ "babel-register": "^6.3.13",
+ "chai": "^2.1.1",
+ "espree": "^1.11.0",
+ "gulp": "^3.8.10",
+ "gulp-bump": "^0.2.2",
+ "gulp-filter": "^2.0.0",
+ "gulp-git": "^1.0.1",
+ "gulp-tag-version": "^1.3.0",
+ "jshint": "^2.5.6",
+ "mocha": "^2.1.0"
+ },
+ "engines": {
+ "node": ">=4.0"
+ },
+ "homepage": "https://github.com/estools/estraverse",
+ "license": "BSD-2-Clause",
+ "main": "estraverse.js",
+ "maintainers": [
+ {
+ "name": "Yusuke Suzuki",
+ "email": "utatane.tea@gmail.com",
+ "url": "http://github.com/Constellation"
+ }
+ ],
+ "name": "estraverse",
+ "repository": {
+ "type": "git",
+ "url": "git+ssh://git@github.com/estools/estraverse.git"
+ },
+ "scripts": {
+ "lint": "jshint estraverse.js",
+ "test": "npm run-script lint && npm run-script unit-test",
+ "unit-test": "mocha --compilers js:babel-register"
+ },
+ "version": "5.2.0"
+}
diff --git a/node_modules/esrecurse/package.json b/node_modules/esrecurse/package.json
new file mode 100755
index 0000000..b8dd029
--- /dev/null
+++ b/node_modules/esrecurse/package.json
@@ -0,0 +1,80 @@
+{
+ "_from": "esrecurse@^4.1.0",
+ "_id": "esrecurse@4.3.0",
+ "_inBundle": false,
+ "_integrity": "sha512-KmfKL3b6G+RXvP8N1vr3Tq1kL/oCFgn2NYXEtqP8/L3pKapUA4G8cFVaoF3SU323CD4XypR/ffioHmkti6/Tag==",
+ "_location": "/esrecurse",
+ "_phantomChildren": {},
+ "_requested": {
+ "type": "range",
+ "registry": true,
+ "raw": "esrecurse@^4.1.0",
+ "name": "esrecurse",
+ "escapedName": "esrecurse",
+ "rawSpec": "^4.1.0",
+ "saveSpec": null,
+ "fetchSpec": "^4.1.0"
+ },
+ "_requiredBy": [
+ "/eslint-scope"
+ ],
+ "_resolved": "https://registry.npmjs.org/esrecurse/-/esrecurse-4.3.0.tgz",
+ "_shasum": "7ad7964d679abb28bee72cec63758b1c5d2c9921",
+ "_spec": "esrecurse@^4.1.0",
+ "_where": "/home/pruss/Dev/3-minute-website/node_modules/eslint-scope",
+ "babel": {
+ "presets": [
+ "es2015"
+ ]
+ },
+ "bugs": {
+ "url": "https://github.com/estools/esrecurse/issues"
+ },
+ "bundleDependencies": false,
+ "dependencies": {
+ "estraverse": "^5.2.0"
+ },
+ "deprecated": false,
+ "description": "ECMAScript AST recursive visitor",
+ "devDependencies": {
+ "babel-cli": "^6.24.1",
+ "babel-eslint": "^7.2.3",
+ "babel-preset-es2015": "^6.24.1",
+ "babel-register": "^6.24.1",
+ "chai": "^4.0.2",
+ "esprima": "^4.0.0",
+ "gulp": "^3.9.0",
+ "gulp-bump": "^2.7.0",
+ "gulp-eslint": "^4.0.0",
+ "gulp-filter": "^5.0.0",
+ "gulp-git": "^2.4.1",
+ "gulp-mocha": "^4.3.1",
+ "gulp-tag-version": "^1.2.1",
+ "jsdoc": "^3.3.0-alpha10",
+ "minimist": "^1.1.0"
+ },
+ "engines": {
+ "node": ">=4.0"
+ },
+ "homepage": "https://github.com/estools/esrecurse",
+ "license": "BSD-2-Clause",
+ "main": "esrecurse.js",
+ "maintainers": [
+ {
+ "name": "Yusuke Suzuki",
+ "email": "utatane.tea@gmail.com",
+ "url": "https://github.com/Constellation"
+ }
+ ],
+ "name": "esrecurse",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/estools/esrecurse.git"
+ },
+ "scripts": {
+ "lint": "gulp lint",
+ "test": "gulp travis",
+ "unit-test": "gulp test"
+ },
+ "version": "4.3.0"
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-23 15:47:30 +0000