node_modules

1 files changed, 259 insertions, 194 deletions

diff --git a/node_modules/acorn/dist/walk.es.js b/node_modules/acorn/dist/walk.es.js
index 280b9a045..153534673 100644
--- a/node_modules/acorn/dist/walk.es.js
+++ b/node_modules/acorn/dist/walk.es.js
@@ -17,28 +17,27 @@
 // state.
 
 function simple(node, visitors, base, state, override) {
-  if (!base) base = exports.base
-  ;(function c(node, st, override) {
-    var type = override || node.type, found = visitors[type]
-    base[type](node, st, c)
-    if (found) found(node, st)
-  })(node, state, override)
+  if (!base) { base = exports.base
+  ; }(function c(node, st, override) {
+    var type = override || node.type, found = visitors[type];
+    base[type](node, st, c);
+    if (found) { found(node, st); }
+  })(node, state, override);
 }
 
 // An ancestor walk keeps an array of ancestor nodes (including the
 // current node) and passes them to the callback as third parameter
 // (and also as state parameter when no other state is present).
 function ancestor(node, visitors, base, state) {
-  if (!base) base = exports.base
-  var ancestors = []
-  ;(function c(node, st, override) {
-    var type = override || node.type, found = visitors[type]
-    var isNew = node != ancestors[ancestors.length - 1]
-    if (isNew) ancestors.push(node)
-    base[type](node, st, c)
-    if (found) found(node, st || ancestors, ancestors)
-    if (isNew) ancestors.pop()
-  })(node, state)
+  if (!base) { base = exports.base; }
+  var ancestors = [];(function c(node, st, override) {
+    var type = override || node.type, found = visitors[type];
+    var isNew = node != ancestors[ancestors.length - 1];
+    if (isNew) { ancestors.push(node); }
+    base[type](node, st, c);
+    if (found) { found(node, st || ancestors, ancestors); }
+    if (isNew) { ancestors.pop(); }
+  })(node, state);
 }
 
 // A recursive walk is one where your functions override the default
@@ -47,42 +46,65 @@ function ancestor(node, visitors, base, state) {
 // their child nodes (by calling their third argument on these
 // nodes).
 function recursive(node, state, funcs, base, override) {
-  var visitor = funcs ? exports.make(funcs, base) : base
-  ;(function c(node, st, override) {
-    visitor[override || node.type](node, st, c)
-  })(node, state, override)
+  var visitor = funcs ? exports.make(funcs, base) : base;(function c(node, st, override) {
+    visitor[override || node.type](node, st, c);
+  })(node, state, override);
 }
 
 function makeTest(test) {
   if (typeof test == "string")
-    return function (type) { return type == test; }
+    { return function (type) { return type == test; } }
   else if (!test)
-    return function () { return true; }
+    { return function () { return true; } }
   else
-    return test
+    { return test }
 }
 
-var Found = function Found(node, state) { this.node = node; this.state = state };
+var Found = function Found(node, state) { this.node = node; this.state = state; };
+
+// A full walk triggers the callback on each node
+function full(node, callback, base, state, override) {
+  if (!base) { base = exports.base
+  ; }(function c(node, st, override) {
+    var type = override || node.type;
+    base[type](node, st, c);
+    callback(node, st, type);
+  })(node, state, override);
+}
+
+// An fullAncestor walk is like an ancestor walk, but triggers
+// the callback on each node
+function fullAncestor(node, callback, base, state) {
+  if (!base) { base = exports.base; }
+  var ancestors = [];(function c(node, st, override) {
+    var type = override || node.type;
+    var isNew = node != ancestors[ancestors.length - 1];
+    if (isNew) { ancestors.push(node); }
+    base[type](node, st, c);
+    callback(node, st || ancestors, ancestors, type);
+    if (isNew) { ancestors.pop(); }
+  })(node, state);
+}
 
 // Find a node with a given start, end, and type (all are optional,
 // null can be used as wildcard). Returns a {node, state} object, or
 // undefined when it doesn't find a matching node.
 function findNodeAt(node, start, end, test, base, state) {
-  test = makeTest(test)
-  if (!base) base = exports.base
+  test = makeTest(test);
+  if (!base) { base = exports.base; }
   try {
     (function c(node, st, override) {
-      var type = override || node.type
+      var type = override || node.type;
       if ((start == null || node.start <= start) &&
           (end == null || node.end >= end))
-        base[type](node, st, c)
+        { base[type](node, st, c); }
       if ((start == null || node.start == start) &&
           (end == null || node.end == end) &&
           test(type, node))
-        throw new Found(node, st)
-    })(node, state)
+        { throw new Found(node, st) }
+    })(node, state);
   } catch (e) {
-    if (e instanceof Found) return e
+    if (e instanceof Found) { return e }
     throw e
   }
 }
@@ -90,253 +112,296 @@ function findNodeAt(node, start, end, test, base, state) {
 // Find the innermost node of a given type that contains the given
 // position. Interface similar to findNodeAt.
 function findNodeAround(node, pos, test, base, state) {
-  test = makeTest(test)
-  if (!base) base = exports.base
+  test = makeTest(test);
+  if (!base) { base = exports.base; }
   try {
     (function c(node, st, override) {
-      var type = override || node.type
-      if (node.start > pos || node.end < pos) return
-      base[type](node, st, c)
-      if (test(type, node)) throw new Found(node, st)
-    })(node, state)
+      var type = override || node.type;
+      if (node.start > pos || node.end < pos) { return }
+      base[type](node, st, c);
+      if (test(type, node)) { throw new Found(node, st) }
+    })(node, state);
   } catch (e) {
-    if (e instanceof Found) return e
+    if (e instanceof Found) { return e }
     throw e
   }
 }
 
 // Find the outermost matching node after a given position.
 function findNodeAfter(node, pos, test, base, state) {
-  test = makeTest(test)
-  if (!base) base = exports.base
+  test = makeTest(test);
+  if (!base) { base = exports.base; }
   try {
     (function c(node, st, override) {
-      if (node.end < pos) return
-      var type = override || node.type
-      if (node.start >= pos && test(type, node)) throw new Found(node, st)
-      base[type](node, st, c)
-    })(node, state)
+      if (node.end < pos) { return }
+      var type = override || node.type;
+      if (node.start >= pos && test(type, node)) { throw new Found(node, st) }
+      base[type](node, st, c);
+    })(node, state);
   } catch (e) {
-    if (e instanceof Found) return e
+    if (e instanceof Found) { return e }
     throw e
   }
 }
 
 // Find the outermost matching node before a given position.
 function findNodeBefore(node, pos, test, base, state) {
-  test = makeTest(test)
-  if (!base) base = exports.base
-  var max
-  ;(function c(node, st, override) {
-    if (node.start > pos) return
-    var type = override || node.type
+  test = makeTest(test);
+  if (!base) { base = exports.base; }
+  var max;(function c(node, st, override) {
+    if (node.start > pos) { return }
+    var type = override || node.type;
     if (node.end <= pos && (!max || max.node.end < node.end) && test(type, node))
-      max = new Found(node, st)
-    base[type](node, st, c)
-  })(node, state)
+      { max = new Found(node, st); }
+    base[type](node, st, c);
+  })(node, state);
   return max
 }
 
 // Fallback to an Object.create polyfill for older environments.
 var create = Object.create || function(proto) {
   function Ctor() {}
-  Ctor.prototype = proto
+  Ctor.prototype = proto;
   return new Ctor
-}
+};
 
 // Used to create a custom walker. Will fill in all missing node
 // type properties with the defaults.
 function make(funcs, base) {
-  if (!base) base = exports.base
-  var visitor = create(base)
-  for (var type in funcs) visitor[type] = funcs[type]
+  if (!base) { base = exports.base; }
+  var visitor = create(base);
+  for (var type in funcs) { visitor[type] = funcs[type]; }
   return visitor
 }
 
-function skipThrough(node, st, c) { c(node, st) }
+function skipThrough(node, st, c) { c(node, st); }
 function ignore(_node, _st, _c) {}
 
 // Node walkers.
 
-var base = {}
+var base = {};
 
 base.Program = base.BlockStatement = function (node, st, c) {
-  for (var i = 0; i < node.body.length; ++i)
-    c(node.body[i], st, "Statement")
-}
-base.Statement = skipThrough
-base.EmptyStatement = ignore
+  for (var i = 0, list = node.body; i < list.length; i += 1)
+    {
+    var stmt = list[i];
+
+    c(stmt, st, "Statement");
+  }
+};
+base.Statement = skipThrough;
+base.EmptyStatement = ignore;
 base.ExpressionStatement = base.ParenthesizedExpression =
-  function (node, st, c) { return c(node.expression, st, "Expression"); }
+  function (node, st, c) { return c(node.expression, st, "Expression"); };
 base.IfStatement = function (node, st, c) {
-  c(node.test, st, "Expression")
-  c(node.consequent, st, "Statement")
-  if (node.alternate) c(node.alternate, st, "Statement")
-}
-base.LabeledStatement = function (node, st, c) { return c(node.body, st, "Statement"); }
-base.BreakStatement = base.ContinueStatement = ignore
+  c(node.test, st, "Expression");
+  c(node.consequent, st, "Statement");
+  if (node.alternate) { c(node.alternate, st, "Statement"); }
+};
+base.LabeledStatement = function (node, st, c) { return c(node.body, st, "Statement"); };
+base.BreakStatement = base.ContinueStatement = ignore;
 base.WithStatement = function (node, st, c) {
-  c(node.object, st, "Expression")
-  c(node.body, st, "Statement")
-}
+  c(node.object, st, "Expression");
+  c(node.body, st, "Statement");
+};
 base.SwitchStatement = function (node, st, c) {
-  c(node.discriminant, st, "Expression")
-  for (var i = 0; i < node.cases.length; ++i) {
-    var cs = node.cases[i]
-    if (cs.test) c(cs.test, st, "Expression")
-    for (var j = 0; j < cs.consequent.length; ++j)
-      c(cs.consequent[j], st, "Statement")
+  c(node.discriminant, st, "Expression");
+  for (var i = 0, list = node.cases; i < list.length; i += 1) {
+    var cs = list[i];
+
+    if (cs.test) { c(cs.test, st, "Expression"); }
+    for (var i$1 = 0, list$1 = cs.consequent; i$1 < list$1.length; i$1 += 1)
+      {
+      var cons = list$1[i$1];
+
+      c(cons, st, "Statement");
+    }
   }
-}
+};
 base.ReturnStatement = base.YieldExpression = base.AwaitExpression = function (node, st, c) {
-  if (node.argument) c(node.argument, st, "Expression")
-}
+  if (node.argument) { c(node.argument, st, "Expression"); }
+};
 base.ThrowStatement = base.SpreadElement =
-  function (node, st, c) { return c(node.argument, st, "Expression"); }
+  function (node, st, c) { return c(node.argument, st, "Expression"); };
 base.TryStatement = function (node, st, c) {
-  c(node.block, st, "Statement")
-  if (node.handler) c(node.handler, st)
-  if (node.finalizer) c(node.finalizer, st, "Statement")
-}
+  c(node.block, st, "Statement");
+  if (node.handler) { c(node.handler, st); }
+  if (node.finalizer) { c(node.finalizer, st, "Statement"); }
+};
 base.CatchClause = function (node, st, c) {
-  c(node.param, st, "Pattern")
-  c(node.body, st, "ScopeBody")
-}
+  c(node.param, st, "Pattern");
+  c(node.body, st, "ScopeBody");
+};
 base.WhileStatement = base.DoWhileStatement = function (node, st, c) {
-  c(node.test, st, "Expression")
-  c(node.body, st, "Statement")
-}
+  c(node.test, st, "Expression");
+  c(node.body, st, "Statement");
+};
 base.ForStatement = function (node, st, c) {
-  if (node.init) c(node.init, st, "ForInit")
-  if (node.test) c(node.test, st, "Expression")
-  if (node.update) c(node.update, st, "Expression")
-  c(node.body, st, "Statement")
-}
+  if (node.init) { c(node.init, st, "ForInit"); }
+  if (node.test) { c(node.test, st, "Expression"); }
+  if (node.update) { c(node.update, st, "Expression"); }
+  c(node.body, st, "Statement");
+};
 base.ForInStatement = base.ForOfStatement = function (node, st, c) {
-  c(node.left, st, "ForInit")
-  c(node.right, st, "Expression")
-  c(node.body, st, "Statement")
-}
+  c(node.left, st, "ForInit");
+  c(node.right, st, "Expression");
+  c(node.body, st, "Statement");
+};
 base.ForInit = function (node, st, c) {
-  if (node.type == "VariableDeclaration") c(node, st)
-  else c(node, st, "Expression")
-}
-base.DebuggerStatement = ignore
+  if (node.type == "VariableDeclaration") { c(node, st); }
+  else { c(node, st, "Expression"); }
+};
+base.DebuggerStatement = ignore;
 
-base.FunctionDeclaration = function (node, st, c) { return c(node, st, "Function"); }
+base.FunctionDeclaration = function (node, st, c) { return c(node, st, "Function"); };
 base.VariableDeclaration = function (node, st, c) {
-  for (var i = 0; i < node.declarations.length; ++i)
-    c(node.declarations[i], st)
-}
+  for (var i = 0, list = node.declarations; i < list.length; i += 1)
+    {
+    var decl = list[i];
+
+    c(decl, st);
+  }
+};
 base.VariableDeclarator = function (node, st, c) {
-  c(node.id, st, "Pattern")
-  if (node.init) c(node.init, st, "Expression")
-}
+  c(node.id, st, "Pattern");
+  if (node.init) { c(node.init, st, "Expression"); }
+};
 
 base.Function = function (node, st, c) {
-  if (node.id) c(node.id, st, "Pattern")
-  for (var i = 0; i < node.params.length; i++)
-    c(node.params[i], st, "Pattern")
-  c(node.body, st, node.expression ? "ScopeExpression" : "ScopeBody")
-}
+  if (node.id) { c(node.id, st, "Pattern"); }
+  for (var i = 0, list = node.params; i < list.length; i += 1)
+    {
+    var param = list[i];
+
+    c(param, st, "Pattern");
+  }
+  c(node.body, st, node.expression ? "ScopeExpression" : "ScopeBody");
+};
 // FIXME drop these node types in next major version
 // (They are awkward, and in ES6 every block can be a scope.)
-base.ScopeBody = function (node, st, c) { return c(node, st, "Statement"); }
-base.ScopeExpression = function (node, st, c) { return c(node, st, "Expression"); }
+base.ScopeBody = function (node, st, c) { return c(node, st, "Statement"); };
+base.ScopeExpression = function (node, st, c) { return c(node, st, "Expression"); };
 
 base.Pattern = function (node, st, c) {
   if (node.type == "Identifier")
-    c(node, st, "VariablePattern")
+    { c(node, st, "VariablePattern"); }
   else if (node.type == "MemberExpression")
-    c(node, st, "MemberPattern")
+    { c(node, st, "MemberPattern"); }
   else
-    c(node, st)
-}
-base.VariablePattern = ignore
-base.MemberPattern = skipThrough
-base.RestElement = function (node, st, c) { return c(node.argument, st, "Pattern"); }
+    { c(node, st); }
+};
+base.VariablePattern = ignore;
+base.MemberPattern = skipThrough;
+base.RestElement = function (node, st, c) { return c(node.argument, st, "Pattern"); };
 base.ArrayPattern = function (node, st, c) {
-  for (var i = 0; i < node.elements.length; ++i) {
-    var elt = node.elements[i]
-    if (elt) c(elt, st, "Pattern")
+  for (var i = 0, list = node.elements; i < list.length; i += 1) {
+    var elt = list[i];
+
+    if (elt) { c(elt, st, "Pattern"); }
   }
-}
+};
 base.ObjectPattern = function (node, st, c) {
-  for (var i = 0; i < node.properties.length; ++i)
-    c(node.properties[i].value, st, "Pattern")
-}
+  for (var i = 0, list = node.properties; i < list.length; i += 1)
+    {
+    var prop = list[i];
+
+    c(prop.value, st, "Pattern");
+  }
+};
 
-base.Expression = skipThrough
-base.ThisExpression = base.Super = base.MetaProperty = ignore
+base.Expression = skipThrough;
+base.ThisExpression = base.Super = base.MetaProperty = ignore;
 base.ArrayExpression = function (node, st, c) {
-  for (var i = 0; i < node.elements.length; ++i) {
-    var elt = node.elements[i]
-    if (elt) c(elt, st, "Expression")
+  for (var i = 0, list = node.elements; i < list.length; i += 1) {
+    var elt = list[i];
+
+    if (elt) { c(elt, st, "Expression"); }
   }
-}
+};
 base.ObjectExpression = function (node, st, c) {
-  for (var i = 0; i < node.properties.length; ++i)
-    c(node.properties[i], st)
-}
-base.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration
+  for (var i = 0, list = node.properties; i < list.length; i += 1)
+    {
+    var prop = list[i];
+
+    c(prop, st);
+  }
+};
+base.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration;
 base.SequenceExpression = base.TemplateLiteral = function (node, st, c) {
-  for (var i = 0; i < node.expressions.length; ++i)
-    c(node.expressions[i], st, "Expression")
-}
+  for (var i = 0, list = node.expressions; i < list.length; i += 1)
+    {
+    var expr = list[i];
+
+    c(expr, st, "Expression");
+  }
+};
 base.UnaryExpression = base.UpdateExpression = function (node, st, c) {
-  c(node.argument, st, "Expression")
-}
+  c(node.argument, st, "Expression");
+};
 base.BinaryExpression = base.LogicalExpression = function (node, st, c) {
-  c(node.left, st, "Expression")
-  c(node.right, st, "Expression")
-}
+  c(node.left, st, "Expression");
+  c(node.right, st, "Expression");
+};
 base.AssignmentExpression = base.AssignmentPattern = function (node, st, c) {
-  c(node.left, st, "Pattern")
-  c(node.right, st, "Expression")
-}
+  c(node.left, st, "Pattern");
+  c(node.right, st, "Expression");
+};
 base.ConditionalExpression = function (node, st, c) {
-  c(node.test, st, "Expression")
-  c(node.consequent, st, "Expression")
-  c(node.alternate, st, "Expression")
-}
+  c(node.test, st, "Expression");
+  c(node.consequent, st, "Expression");
+  c(node.alternate, st, "Expression");
+};
 base.NewExpression = base.CallExpression = function (node, st, c) {
-  c(node.callee, st, "Expression")
-  if (node.arguments) for (var i = 0; i < node.arguments.length; ++i)
-    c(node.arguments[i], st, "Expression")
-}
+  c(node.callee, st, "Expression");
+  if (node.arguments)
+    { for (var i = 0, list = node.arguments; i < list.length; i += 1)
+      {
+        var arg = list[i];
+
+        c(arg, st, "Expression");
+      } }
+};
 base.MemberExpression = function (node, st, c) {
-  c(node.object, st, "Expression")
-  if (node.computed) c(node.property, st, "Expression")
-}
+  c(node.object, st, "Expression");
+  if (node.computed) { c(node.property, st, "Expression"); }
+};
 base.ExportNamedDeclaration = base.ExportDefaultDeclaration = function (node, st, c) {
   if (node.declaration)
-    c(node.declaration, st, node.type == "ExportNamedDeclaration" || node.declaration.id ? "Statement" : "Expression")
-  if (node.source) c(node.source, st, "Expression")
-}
+    { c(node.declaration, st, node.type == "ExportNamedDeclaration" || node.declaration.id ? "Statement" : "Expression"); }
+  if (node.source) { c(node.source, st, "Expression"); }
+};
 base.ExportAllDeclaration = function (node, st, c) {
-  c(node.source, st, "Expression")
-}
+  c(node.source, st, "Expression");
+};
 base.ImportDeclaration = function (node, st, c) {
-  for (var i = 0; i < node.specifiers.length; i++)
-    c(node.specifiers[i], st)
-  c(node.source, st, "Expression")
-}
-base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.Literal = ignore
+  for (var i = 0, list = node.specifiers; i < list.length; i += 1)
+    {
+    var spec = list[i];
+
+    c(spec, st);
+  }
+  c(node.source, st, "Expression");
+};
+base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.Literal = ignore;
 
 base.TaggedTemplateExpression = function (node, st, c) {
-  c(node.tag, st, "Expression")
-  c(node.quasi, st)
-}
-base.ClassDeclaration = base.ClassExpression = function (node, st, c) { return c(node, st, "Class"); }
+  c(node.tag, st, "Expression");
+  c(node.quasi, st);
+};
+base.ClassDeclaration = base.ClassExpression = function (node, st, c) { return c(node, st, "Class"); };
 base.Class = function (node, st, c) {
-  if (node.id) c(node.id, st, "Pattern")
-  if (node.superClass) c(node.superClass, st, "Expression")
-  for (var i = 0; i < node.body.body.length; i++)
-    c(node.body.body[i], st)
-}
+  if (node.id) { c(node.id, st, "Pattern"); }
+  if (node.superClass) { c(node.superClass, st, "Expression"); }
+  for (var i = 0, list = node.body.body; i < list.length; i += 1)
+    {
+    var item = list[i];
+
+    c(item, st);
+  }
+};
 base.MethodDefinition = base.Property = function (node, st, c) {
-  if (node.computed) c(node.key, st, "Expression")
-  c(node.value, st, "Expression")
-}
+  if (node.computed) { c(node.key, st, "Expression"); }
+  c(node.value, st, "Expression");
+};
 
-export { simple, ancestor, recursive, findNodeAt, findNodeAround, findNodeAfter, findNodeBefore, make, base };
\ No newline at end of file
+export { simple, ancestor, recursive, full, fullAncestor, findNodeAt, findNodeAround, findNodeAfter, findNodeBefore, make, base };