sequenceserver 2.0.0 → 2.2.0

data/public/vendor/npm/jstransform@10.1.0/visitors/es6-arrow-function-visitors.js

@@ -1,66 +0,0 @@
-/* */ 
-var restParamVisitors = require("./es6-rest-param-visitors");
-var destructuringVisitors = require("./es6-destructuring-visitors");
-var Syntax = require("esprima-fb").Syntax;
-var utils = require("../src/utils");
-function visitArrowFunction(traverse, node, path, state) {
-  var notInExpression = (path[0].type === Syntax.ExpressionStatement);
-  if (notInExpression) {
-    utils.append('(', state);
-  }
-  utils.append('function', state);
-  renderParams(traverse, node, path, state);
-  utils.catchupWhiteSpace(node.body.range[0], state);
-  var renderBody = node.body.type == Syntax.BlockStatement ? renderStatementBody : renderExpressionBody;
-  path.unshift(node);
-  renderBody(traverse, node, path, state);
-  path.shift();
-  var containsBindingSyntax = utils.containsChildMatching(node.body, function(node) {
-    return node.type === Syntax.ThisExpression || (node.type === Syntax.Identifier && node.name === "super");
-  });
-  if (containsBindingSyntax) {
-    utils.append('.bind(this)', state);
-  }
-  utils.catchupWhiteSpace(node.range[1], state);
-  if (notInExpression) {
-    utils.append(')', state);
-  }
-  return false;
-}
-function renderParams(traverse, node, path, state) {
-  if (isParensFreeSingleParam(node, state) || !node.params.length) {
-    utils.append('(', state);
-  }
-  if (node.params.length !== 0) {
-    path.unshift(node);
-    traverse(node.params, path, state);
-    path.unshift();
-  }
-  utils.append(')', state);
-}
-function isParensFreeSingleParam(node, state) {
-  return node.params.length === 1 && state.g.source[state.g.position] !== '(';
-}
-function renderExpressionBody(traverse, node, path, state) {
-  utils.append('{', state);
-  if (node.rest) {
-    utils.append(restParamVisitors.renderRestParamSetup(node, state), state);
-  }
-  destructuringVisitors.renderDestructuredComponents(node, utils.updateState(state, {localScope: {
-      parentNode: state.parentNode,
-      parentScope: state.parentScope,
-      identifiers: state.identifiers,
-      tempVarIndex: 0
-    }}));
-  utils.append('return ', state);
-  renderStatementBody(traverse, node, path, state);
-  utils.append(';}', state);
-}
-function renderStatementBody(traverse, node, path, state) {
-  traverse(node.body, path, state);
-  utils.catchup(node.body.range[1], state);
-}
-visitArrowFunction.test = function(node, path, state) {
-  return node.type === Syntax.ArrowFunctionExpression;
-};
-exports.visitorList = [visitArrowFunction];

data/public/vendor/npm/jstransform@10.1.0/visitors/es6-call-spread-visitors.js

@@ -1,72 +0,0 @@
-/* */ 
-(function(process) {
-  var Syntax = require("esprima-fb").Syntax;
-  var utils = require("../src/utils");
-  function process(traverse, node, path, state) {
-    utils.move(node.range[0], state);
-    traverse(node, path, state);
-    utils.catchup(node.range[1], state);
-  }
-  function visitCallSpread(traverse, node, path, state) {
-    utils.catchup(node.range[0], state);
-    if (node.type === Syntax.NewExpression) {
-      utils.append('new (Function.prototype.bind.apply(', state);
-      process(traverse, node.callee, path, state);
-    } else if (node.callee.type === Syntax.MemberExpression) {
-      var tempVar = utils.injectTempVar(state);
-      utils.append('(' + tempVar + ' = ', state);
-      process(traverse, node.callee.object, path, state);
-      utils.append(')', state);
-      if (node.callee.property.type === Syntax.Identifier) {
-        utils.append('.', state);
-        process(traverse, node.callee.property, path, state);
-      } else {
-        utils.append('[', state);
-        process(traverse, node.callee.property, path, state);
-        utils.append(']', state);
-      }
-      utils.append('.apply(' + tempVar, state);
-    } else {
-      var needsToBeWrappedInParenthesis = node.callee.type === Syntax.FunctionDeclaration || node.callee.type === Syntax.FunctionExpression;
-      if (needsToBeWrappedInParenthesis) {
-        utils.append('(', state);
-      }
-      process(traverse, node.callee, path, state);
-      if (needsToBeWrappedInParenthesis) {
-        utils.append(')', state);
-      }
-      utils.append('.apply(null', state);
-    }
-    utils.append(', ', state);
-    var args = node.arguments.slice();
-    var spread = args.pop();
-    if (args.length || node.type === Syntax.NewExpression) {
-      utils.append('[', state);
-      if (node.type === Syntax.NewExpression) {
-        utils.append('null' + (args.length ? ', ' : ''), state);
-      }
-      while (args.length) {
-        var arg = args.shift();
-        utils.move(arg.range[0], state);
-        traverse(arg, path, state);
-        if (args.length) {
-          utils.catchup(args[0].range[0], state);
-        } else {
-          utils.catchup(arg.range[1], state);
-        }
-      }
-      utils.append('].concat(', state);
-      process(traverse, spread.argument, path, state);
-      utils.append(')', state);
-    } else {
-      process(traverse, spread.argument, path, state);
-    }
-    utils.append(node.type === Syntax.NewExpression ? '))' : ')', state);
-    utils.move(node.range[1], state);
-    return false;
-  }
-  visitCallSpread.test = function(node, path, state) {
-    return ((node.type === Syntax.CallExpression || node.type === Syntax.NewExpression) && node.arguments.length > 0 && node.arguments[node.arguments.length - 1].type === Syntax.SpreadElement);
-  };
-  exports.visitorList = [visitCallSpread];
-})(require("process"));

data/public/vendor/npm/jstransform@10.1.0/visitors/es6-class-visitors.js

@@ -1,316 +0,0 @@
-/* */ 
-'use strict';
-var base62 = require("base62");
-var Syntax = require("esprima-fb").Syntax;
-var utils = require("../src/utils");
-var reservedWordsHelper = require("./reserved-words-helper");
-var declareIdentInLocalScope = utils.declareIdentInLocalScope;
-var initScopeMetadata = utils.initScopeMetadata;
-var SUPER_PROTO_IDENT_PREFIX = '____SuperProtoOf';
-var _anonClassUUIDCounter = 0;
-var _mungedSymbolMaps = {};
-function resetSymbols() {
-  _anonClassUUIDCounter = 0;
-  _mungedSymbolMaps = {};
-}
-function _generateAnonymousClassName(state) {
-  var mungeNamespace = state.mungeNamespace || '';
-  return '____Class' + mungeNamespace + base62.encode(_anonClassUUIDCounter++);
-}
-function _getMungedName(identName, state) {
-  var mungeNamespace = state.mungeNamespace;
-  var shouldMinify = state.g.opts.minify;
-  if (shouldMinify) {
-    if (!_mungedSymbolMaps[mungeNamespace]) {
-      _mungedSymbolMaps[mungeNamespace] = {
-        symbolMap: {},
-        identUUIDCounter: 0
-      };
-    }
-    var symbolMap = _mungedSymbolMaps[mungeNamespace].symbolMap;
-    if (!symbolMap[identName]) {
-      symbolMap[identName] = base62.encode(_mungedSymbolMaps[mungeNamespace].identUUIDCounter++);
-    }
-    identName = symbolMap[identName];
-  }
-  return '$' + mungeNamespace + identName;
-}
-function _getSuperClassInfo(node, state) {
-  var ret = {
-    name: null,
-    expression: null
-  };
-  if (node.superClass) {
-    if (node.superClass.type === Syntax.Identifier) {
-      ret.name = node.superClass.name;
-    } else {
-      ret.name = _generateAnonymousClassName(state);
-      ret.expression = state.g.source.substring(node.superClass.range[0], node.superClass.range[1]);
-    }
-  }
-  return ret;
-}
-function _isConstructorMethod(classElement) {
-  return classElement.type === Syntax.MethodDefinition && classElement.key.type === Syntax.Identifier && classElement.key.name === 'constructor';
-}
-function _shouldMungeIdentifier(node, state) {
-  return (!!state.methodFuncNode && !utils.getDocblock(state).hasOwnProperty('preventMunge') && /^_(?!_)/.test(node.name));
-}
-function visitClassMethod(traverse, node, path, state) {
-  if (!state.g.opts.es5 && (node.kind === 'get' || node.kind === 'set')) {
-    throw new Error('This transform does not support ' + node.kind + 'ter methods for ES6 ' + 'classes. (line: ' + node.loc.start.line + ', col: ' + node.loc.start.column + ')');
-  }
-  state = utils.updateState(state, {methodNode: node});
-  utils.catchup(node.range[0], state);
-  path.unshift(node);
-  traverse(node.value, path, state);
-  path.shift();
-  return false;
-}
-visitClassMethod.test = function(node, path, state) {
-  return node.type === Syntax.MethodDefinition;
-};
-function visitClassFunctionExpression(traverse, node, path, state) {
-  var methodNode = path[0];
-  var isGetter = methodNode.kind === 'get';
-  var isSetter = methodNode.kind === 'set';
-  state = utils.updateState(state, {methodFuncNode: node});
-  if (methodNode.key.name === 'constructor') {
-    utils.append('function ' + state.className, state);
-  } else {
-    var methodAccessorComputed = false;
-    var methodAccessor;
-    var prototypeOrStatic = methodNode.static ? '' : '.prototype';
-    var objectAccessor = state.className + prototypeOrStatic;
-    if (methodNode.key.type === Syntax.Identifier) {
-      methodAccessor = methodNode.key.name;
-      if (_shouldMungeIdentifier(methodNode.key, state)) {
-        methodAccessor = _getMungedName(methodAccessor, state);
-      }
-      if (isGetter || isSetter) {
-        methodAccessor = JSON.stringify(methodAccessor);
-      } else if (reservedWordsHelper.isReservedWord(methodAccessor)) {
-        methodAccessorComputed = true;
-        methodAccessor = JSON.stringify(methodAccessor);
-      }
-    } else if (methodNode.key.type === Syntax.Literal) {
-      methodAccessor = JSON.stringify(methodNode.key.value);
-      methodAccessorComputed = true;
-    }
-    if (isSetter || isGetter) {
-      utils.append('Object.defineProperty(' + objectAccessor + ',' + methodAccessor + ',' + '{configurable:true,' + methodNode.kind + ':function', state);
-    } else {
-      if (state.g.opts.es3) {
-        if (methodAccessorComputed) {
-          methodAccessor = '[' + methodAccessor + ']';
-        } else {
-          methodAccessor = '.' + methodAccessor;
-        }
-        utils.append(objectAccessor + methodAccessor + '=function' + (node.generator ? '*' : ''), state);
-      } else {
-        if (!methodAccessorComputed) {
-          methodAccessor = JSON.stringify(methodAccessor);
-        }
-        utils.append('Object.defineProperty(' + objectAccessor + ',' + methodAccessor + ',' + '{writable:true,configurable:true,' + 'value:function' + (node.generator ? '*' : ''), state);
-      }
-    }
-  }
-  utils.move(methodNode.key.range[1], state);
-  utils.append('(', state);
-  var params = node.params;
-  if (params.length > 0) {
-    utils.catchupNewlines(params[0].range[0], state);
-    for (var i = 0; i < params.length; i++) {
-      utils.catchup(node.params[i].range[0], state);
-      path.unshift(node);
-      traverse(params[i], path, state);
-      path.shift();
-    }
-  }
-  var closingParenPosition = utils.getNextSyntacticCharOffset(')', state);
-  utils.catchupWhiteSpace(closingParenPosition, state);
-  var openingBracketPosition = utils.getNextSyntacticCharOffset('{', state);
-  utils.catchup(openingBracketPosition + 1, state);
-  if (!state.scopeIsStrict) {
-    utils.append('"use strict";', state);
-    state = utils.updateState(state, {scopeIsStrict: true});
-  }
-  utils.move(node.body.range[0] + '{'.length, state);
-  path.unshift(node);
-  traverse(node.body, path, state);
-  path.shift();
-  utils.catchup(node.body.range[1], state);
-  if (methodNode.key.name !== 'constructor') {
-    if (isGetter || isSetter || !state.g.opts.es3) {
-      utils.append('})', state);
-    }
-    utils.append(';', state);
-  }
-  return false;
-}
-visitClassFunctionExpression.test = function(node, path, state) {
-  return node.type === Syntax.FunctionExpression && path[0].type === Syntax.MethodDefinition;
-};
-function visitClassMethodParam(traverse, node, path, state) {
-  var paramName = node.name;
-  if (_shouldMungeIdentifier(node, state)) {
-    paramName = _getMungedName(node.name, state);
-  }
-  utils.append(paramName, state);
-  utils.move(node.range[1], state);
-}
-visitClassMethodParam.test = function(node, path, state) {
-  if (!path[0] || !path[1]) {
-    return;
-  }
-  var parentFuncExpr = path[0];
-  var parentClassMethod = path[1];
-  return parentFuncExpr.type === Syntax.FunctionExpression && parentClassMethod.type === Syntax.MethodDefinition && node.type === Syntax.Identifier;
-};
-function _renderClassBody(traverse, node, path, state) {
-  var className = state.className;
-  var superClass = state.superClass;
-  if (superClass.name) {
-    if (superClass.expression !== null) {
-      utils.append('var ' + superClass.name + '=' + superClass.expression + ';', state);
-    }
-    var keyName = superClass.name + '____Key';
-    var keyNameDeclarator = '';
-    if (!utils.identWithinLexicalScope(keyName, state)) {
-      keyNameDeclarator = 'var ';
-      declareIdentInLocalScope(keyName, initScopeMetadata(node), state);
-    }
-    utils.append('for(' + keyNameDeclarator + keyName + ' in ' + superClass.name + '){' + 'if(' + superClass.name + '.hasOwnProperty(' + keyName + ')){' + className + '[' + keyName + ']=' + superClass.name + '[' + keyName + '];' + '}' + '}', state);
-    var superProtoIdentStr = SUPER_PROTO_IDENT_PREFIX + superClass.name;
-    if (!utils.identWithinLexicalScope(superProtoIdentStr, state)) {
-      utils.append('var ' + superProtoIdentStr + '=' + superClass.name + '===null?' + 'null:' + superClass.name + '.prototype;', state);
-      declareIdentInLocalScope(superProtoIdentStr, initScopeMetadata(node), state);
-    }
-    utils.append(className + '.prototype=Object.create(' + superProtoIdentStr + ');', state);
-    utils.append(className + '.prototype.constructor=' + className + ';', state);
-    utils.append(className + '.__superConstructor__=' + superClass.name + ';', state);
-  }
-  if (!node.body.body.filter(_isConstructorMethod).pop()) {
-    utils.append('function ' + className + '(){', state);
-    if (!state.scopeIsStrict) {
-      utils.append('"use strict";', state);
-    }
-    if (superClass.name) {
-      utils.append('if(' + superClass.name + '!==null){' + superClass.name + '.apply(this,arguments);}', state);
-    }
-    utils.append('}', state);
-  }
-  utils.move(node.body.range[0] + '{'.length, state);
-  traverse(node.body, path, state);
-  utils.catchupWhiteSpace(node.range[1], state);
-}
-function visitClassDeclaration(traverse, node, path, state) {
-  var className = node.id.name;
-  var superClass = _getSuperClassInfo(node, state);
-  state = utils.updateState(state, {
-    mungeNamespace: className,
-    className: className,
-    superClass: superClass
-  });
-  _renderClassBody(traverse, node, path, state);
-  return false;
-}
-visitClassDeclaration.test = function(node, path, state) {
-  return node.type === Syntax.ClassDeclaration;
-};
-function visitClassExpression(traverse, node, path, state) {
-  var className = node.id && node.id.name || _generateAnonymousClassName(state);
-  var superClass = _getSuperClassInfo(node, state);
-  utils.append('(function(){', state);
-  state = utils.updateState(state, {
-    mungeNamespace: className,
-    className: className,
-    superClass: superClass
-  });
-  _renderClassBody(traverse, node, path, state);
-  utils.append('return ' + className + ';})()', state);
-  return false;
-}
-visitClassExpression.test = function(node, path, state) {
-  return node.type === Syntax.ClassExpression;
-};
-function visitPrivateIdentifier(traverse, node, path, state) {
-  utils.append(_getMungedName(node.name, state), state);
-  utils.move(node.range[1], state);
-}
-visitPrivateIdentifier.test = function(node, path, state) {
-  if (node.type === Syntax.Identifier && _shouldMungeIdentifier(node, state)) {
-    if (path[0].type === Syntax.MemberExpression && path[0].object !== node && path[0].computed === false) {
-      return true;
-    }
-    if (utils.identWithinLexicalScope(node.name, state, state.methodFuncNode)) {
-      return true;
-    }
-    if (path[0].type === Syntax.Property && path[1].type === Syntax.ObjectExpression) {
-      return true;
-    }
-    if (path[0].type === Syntax.FunctionExpression || path[0].type === Syntax.FunctionDeclaration || path[0].type === Syntax.ArrowFunctionExpression) {
-      for (var i = 0; i < path[0].params.length; i++) {
-        if (path[0].params[i] === node) {
-          return true;
-        }
-      }
-    }
-  }
-  return false;
-};
-function visitSuperCallExpression(traverse, node, path, state) {
-  var superClassName = state.superClass.name;
-  if (node.callee.type === Syntax.Identifier) {
-    if (_isConstructorMethod(state.methodNode)) {
-      utils.append(superClassName + '.call(', state);
-    } else {
-      var protoProp = SUPER_PROTO_IDENT_PREFIX + superClassName;
-      if (state.methodNode.key.type === Syntax.Identifier) {
-        protoProp += '.' + state.methodNode.key.name;
-      } else if (state.methodNode.key.type === Syntax.Literal) {
-        protoProp += '[' + JSON.stringify(state.methodNode.key.value) + ']';
-      }
-      utils.append(protoProp + ".call(", state);
-    }
-    utils.move(node.callee.range[1], state);
-  } else if (node.callee.type === Syntax.MemberExpression) {
-    utils.append(SUPER_PROTO_IDENT_PREFIX + superClassName, state);
-    utils.move(node.callee.object.range[1], state);
-    if (node.callee.computed) {
-      utils.catchup(node.callee.property.range[1] + ']'.length, state);
-    } else {
-      utils.append('.' + node.callee.property.name, state);
-    }
-    utils.append('.call(', state);
-    utils.move(node.callee.range[1], state);
-  }
-  utils.append('this', state);
-  if (node.arguments.length > 0) {
-    utils.append(',', state);
-    utils.catchupWhiteSpace(node.arguments[0].range[0], state);
-    traverse(node.arguments, path, state);
-  }
-  utils.catchupWhiteSpace(node.range[1], state);
-  utils.append(')', state);
-  return false;
-}
-visitSuperCallExpression.test = function(node, path, state) {
-  if (state.superClass && node.type === Syntax.CallExpression) {
-    var callee = node.callee;
-    if (callee.type === Syntax.Identifier && callee.name === 'super' || callee.type == Syntax.MemberExpression && callee.object.name === 'super') {
-      return true;
-    }
-  }
-  return false;
-};
-function visitSuperMemberExpression(traverse, node, path, state) {
-  var superClassName = state.superClass.name;
-  utils.append(SUPER_PROTO_IDENT_PREFIX + superClassName, state);
-  utils.move(node.object.range[1], state);
-}
-visitSuperMemberExpression.test = function(node, path, state) {
-  return state.superClass && node.type === Syntax.MemberExpression && node.object.type === Syntax.Identifier && node.object.name === 'super';
-};
-exports.resetSymbols = resetSymbols;
-exports.visitorList = [visitClassDeclaration, visitClassExpression, visitClassFunctionExpression, visitClassMethod, visitClassMethodParam, visitPrivateIdentifier, visitSuperCallExpression, visitSuperMemberExpression];

data/public/vendor/npm/jstransform@10.1.0/visitors/es6-destructuring-visitors.js

@@ -1,135 +0,0 @@
-/* */ 
-var Syntax = require("esprima-fb").Syntax;
-var utils = require("../src/utils");
-var reservedWordsHelper = require("./reserved-words-helper");
-var restParamVisitors = require("./es6-rest-param-visitors");
-var restPropertyHelpers = require("./es7-rest-property-helpers");
-function visitStructuredVariable(traverse, node, path, state) {
-  utils.append(utils.getTempVar(state.localScope.tempVarIndex) + '=', state);
-  utils.catchupWhiteSpace(node.init.range[0], state);
-  traverse(node.init, path, state);
-  utils.catchup(node.init.range[1], state);
-  utils.append(',' + getDestructuredComponents(node.id, state), state);
-  state.localScope.tempVarIndex++;
-  return false;
-}
-visitStructuredVariable.test = function(node, path, state) {
-  return node.type === Syntax.VariableDeclarator && isStructuredPattern(node.id);
-};
-function isStructuredPattern(node) {
-  return node.type === Syntax.ObjectPattern || node.type === Syntax.ArrayPattern;
-}
-function getDestructuredComponents(node, state) {
-  var tmpIndex = state.localScope.tempVarIndex;
-  var components = [];
-  var patternItems = getPatternItems(node);
-  for (var idx = 0; idx < patternItems.length; idx++) {
-    var item = patternItems[idx];
-    if (!item) {
-      continue;
-    }
-    if (item.type === Syntax.SpreadElement) {
-      components.push(item.argument.name + '=Array.prototype.slice.call(' + utils.getTempVar(tmpIndex) + ',' + idx + ')');
-      continue;
-    }
-    if (item.type === Syntax.SpreadProperty) {
-      var restExpression = restPropertyHelpers.renderRestExpression(utils.getTempVar(tmpIndex), patternItems);
-      components.push(item.argument.name + '=' + restExpression);
-      continue;
-    }
-    var accessor = getPatternItemAccessor(node, item, tmpIndex, idx);
-    var value = getPatternItemValue(node, item);
-    if (value.type === Syntax.Identifier) {
-      components.push(value.name + '=' + accessor);
-    } else {
-      components.push(utils.getTempVar(++state.localScope.tempVarIndex) + '=' + accessor + ',' + getDestructuredComponents(value, state));
-    }
-  }
-  return components.join(',');
-}
-function getPatternItems(node) {
-  return node.properties || node.elements;
-}
-function getPatternItemAccessor(node, patternItem, tmpIndex, idx) {
-  var tmpName = utils.getTempVar(tmpIndex);
-  if (node.type === Syntax.ObjectPattern) {
-    if (reservedWordsHelper.isReservedWord(patternItem.key.name)) {
-      return tmpName + '["' + patternItem.key.name + '"]';
-    } else if (patternItem.key.type === Syntax.Literal) {
-      return tmpName + '[' + JSON.stringify(patternItem.key.value) + ']';
-    } else if (patternItem.key.type === Syntax.Identifier) {
-      return tmpName + '.' + patternItem.key.name;
-    }
-  } else if (node.type === Syntax.ArrayPattern) {
-    return tmpName + '[' + idx + ']';
-  }
-}
-function getPatternItemValue(node, patternItem) {
-  return node.type === Syntax.ObjectPattern ? patternItem.value : patternItem;
-}
-function visitStructuredAssignment(traverse, node, path, state) {
-  var exprNode = node.expression;
-  utils.append('var ' + utils.getTempVar(state.localScope.tempVarIndex) + '=', state);
-  utils.catchupWhiteSpace(exprNode.right.range[0], state);
-  traverse(exprNode.right, path, state);
-  utils.catchup(exprNode.right.range[1], state);
-  utils.append(';' + getDestructuredComponents(exprNode.left, state) + ';', state);
-  utils.catchupWhiteSpace(node.range[1], state);
-  state.localScope.tempVarIndex++;
-  return false;
-}
-visitStructuredAssignment.test = function(node, path, state) {
-  return node.type === Syntax.ExpressionStatement && node.expression.type === Syntax.AssignmentExpression && isStructuredPattern(node.expression.left);
-};
-function visitStructuredParameter(traverse, node, path, state) {
-  utils.append(utils.getTempVar(getParamIndex(node, path)), state);
-  utils.catchupWhiteSpace(node.range[1], state);
-  return true;
-}
-function getParamIndex(paramNode, path) {
-  var funcNode = path[0];
-  var tmpIndex = 0;
-  for (var k = 0; k < funcNode.params.length; k++) {
-    var param = funcNode.params[k];
-    if (param === paramNode) {
-      break;
-    }
-    if (isStructuredPattern(param)) {
-      tmpIndex++;
-    }
-  }
-  return tmpIndex;
-}
-visitStructuredParameter.test = function(node, path, state) {
-  return isStructuredPattern(node) && isFunctionNode(path[0]);
-};
-function isFunctionNode(node) {
-  return (node.type == Syntax.FunctionDeclaration || node.type == Syntax.FunctionExpression || node.type == Syntax.MethodDefinition || node.type == Syntax.ArrowFunctionExpression);
-}
-function visitFunctionBodyForStructuredParameter(traverse, node, path, state) {
-  var funcNode = path[0];
-  utils.catchup(funcNode.body.range[0] + 1, state);
-  renderDestructuredComponents(funcNode, state);
-  if (funcNode.rest) {
-    utils.append(restParamVisitors.renderRestParamSetup(funcNode, state), state);
-  }
-  return true;
-}
-function renderDestructuredComponents(funcNode, state) {
-  var destructuredComponents = [];
-  for (var k = 0; k < funcNode.params.length; k++) {
-    var param = funcNode.params[k];
-    if (isStructuredPattern(param)) {
-      destructuredComponents.push(getDestructuredComponents(param, state));
-      state.localScope.tempVarIndex++;
-    }
-  }
-  if (destructuredComponents.length) {
-    utils.append('var ' + destructuredComponents.join(',') + ';', state);
-  }
-}
-visitFunctionBodyForStructuredParameter.test = function(node, path, state) {
-  return node.type === Syntax.BlockStatement && isFunctionNode(path[0]);
-};
-exports.visitorList = [visitStructuredVariable, visitStructuredAssignment, visitStructuredParameter, visitFunctionBodyForStructuredParameter];
-exports.renderDestructuredComponents = renderDestructuredComponents;

data/public/vendor/npm/jstransform@10.1.0/visitors/es6-object-concise-method-visitors.js

@@ -1,28 +0,0 @@
-/* */ 
-var Syntax = require("esprima-fb").Syntax;
-var utils = require("../src/utils");
-var reservedWordsHelper = require("./reserved-words-helper");
-function visitObjectConciseMethod(traverse, node, path, state) {
-  var isGenerator = node.value.generator;
-  if (isGenerator) {
-    utils.catchupWhiteSpace(node.range[0] + 1, state);
-  }
-  if (node.computed) {
-    utils.catchup(node.key.range[1] + 1, state);
-  } else if (reservedWordsHelper.isReservedWord(node.key.name)) {
-    utils.catchup(node.key.range[0], state);
-    utils.append('"', state);
-    utils.catchup(node.key.range[1], state);
-    utils.append('"', state);
-  }
-  utils.catchup(node.key.range[1], state);
-  utils.append(':function' + (isGenerator ? '*' : ''), state);
-  path.unshift(node);
-  traverse(node.value, path, state);
-  path.shift();
-  return false;
-}
-visitObjectConciseMethod.test = function(node, path, state) {
-  return node.type === Syntax.Property && node.value.type === Syntax.FunctionExpression && node.method === true;
-};
-exports.visitorList = [visitObjectConciseMethod];

data/public/vendor/npm/jstransform@10.1.0/visitors/es6-object-short-notation-visitors.js

@@ -1,12 +0,0 @@
-/* */ 
-var Syntax = require("esprima-fb").Syntax;
-var utils = require("../src/utils");
-function visitObjectLiteralShortNotation(traverse, node, path, state) {
-  utils.catchup(node.key.range[1], state);
-  utils.append(':' + node.key.name, state);
-  return false;
-}
-visitObjectLiteralShortNotation.test = function(node, path, state) {
-  return node.type === Syntax.Property && node.kind === 'init' && node.shorthand === true && path[0].type !== Syntax.ObjectPattern;
-};
-exports.visitorList = [visitObjectLiteralShortNotation];

data/public/vendor/npm/jstransform@10.1.0/visitors/es6-rest-param-visitors.js

@@ -1,45 +0,0 @@
-/* */ 
-var Syntax = require("esprima-fb").Syntax;
-var utils = require("../src/utils");
-function _nodeIsFunctionWithRestParam(node) {
-  return (node.type === Syntax.FunctionDeclaration || node.type === Syntax.FunctionExpression || node.type === Syntax.ArrowFunctionExpression) && node.rest;
-}
-function visitFunctionParamsWithRestParam(traverse, node, path, state) {
-  if (node.parametricType) {
-    utils.catchup(node.parametricType.range[0], state);
-    path.unshift(node);
-    traverse(node.parametricType, path, state);
-    path.shift();
-  }
-  if (node.params.length) {
-    path.unshift(node);
-    traverse(node.params, path, state);
-    path.shift();
-  } else {
-    utils.catchup(node.rest.range[0] - 3, state);
-  }
-  utils.catchupWhiteSpace(node.rest.range[1], state);
-  path.unshift(node);
-  traverse(node.body, path, state);
-  path.shift();
-  return false;
-}
-visitFunctionParamsWithRestParam.test = function(node, path, state) {
-  return _nodeIsFunctionWithRestParam(node);
-};
-function renderRestParamSetup(functionNode, state) {
-  var idx = state.localScope.tempVarIndex++;
-  var len = state.localScope.tempVarIndex++;
-  return 'for (var ' + functionNode.rest.name + '=[],' + utils.getTempVar(idx) + '=' + functionNode.params.length + ',' + utils.getTempVar(len) + '=arguments.length;' + utils.getTempVar(idx) + '<' + utils.getTempVar(len) + ';' + utils.getTempVar(idx) + '++) ' + functionNode.rest.name + '.push(arguments[' + utils.getTempVar(idx) + ']);';
-}
-function visitFunctionBodyWithRestParam(traverse, node, path, state) {
-  utils.catchup(node.range[0] + 1, state);
-  var parentNode = path[0];
-  utils.append(renderRestParamSetup(parentNode, state), state);
-  return true;
-}
-visitFunctionBodyWithRestParam.test = function(node, path, state) {
-  return node.type === Syntax.BlockStatement && _nodeIsFunctionWithRestParam(path[0]);
-};
-exports.renderRestParamSetup = renderRestParamSetup;
-exports.visitorList = [visitFunctionParamsWithRestParam, visitFunctionBodyWithRestParam];