sequenceserver 2.0.0 → 2.1.0

data/public/vendor/npm/jstransform@10.1.0/polyfill/Object.es6.js

@@ -1,54 +0,0 @@
-/* */ 
-"format cjs";
-/**
- * Copyright 2014 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @provides Object.es6
- * @polyfill
- */
-
-// https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object.assign
-
-if (!Object.assign) {
-  Object.assign = function(target, sources) {
-    if (target === null || target === undefined) {
-      throw new TypeError('Object.assign target cannot be null or undefined');
-    }
-
-    var to = Object(target);
-    var hasOwnProperty = Object.prototype.hasOwnProperty;
-
-    for (var nextIndex = 1; nextIndex < arguments.length; nextIndex++) {
-      var nextSource = arguments[nextIndex];
-      if (nextSource === null || nextSource === undefined) {
-        continue;
-      }
-
-      var from = Object(nextSource);
-
-      // We don't currently support accessors nor proxies. Therefore this
-      // copy cannot throw. If we ever supported this then we must handle
-      // exceptions and side-effects.
-
-      for (var key in from) {
-        if (hasOwnProperty.call(from, key)) {
-          to[key] = from[key];
-        }
-      }
-    }
-
-    return to;
-  };
-}

data/public/vendor/npm/jstransform@10.1.0/src/__tests__/jstransform-test.js

@@ -1,246 +0,0 @@
-/* */ 
-require("mock-modules").autoMockOff();
-describe('jstransform', function() {
-  var transformFn;
-  var Syntax = require("esprima-fb").Syntax;
-  beforeEach(function() {
-    require("mock-modules").dumpCache();
-    transformFn = require("../jstransform").transform;
-  });
-  function _runVisitor(source, nodeCount, visitor) {
-    var actualVisitationCount = 0;
-    function shimVisitor(traverse, node, path, state) {
-      actualVisitationCount++;
-      return visitor(traverse, node, path, state);
-    }
-    shimVisitor.test = visitor.test;
-    transformFn([shimVisitor], source);
-    expect(actualVisitationCount).toBe(nodeCount);
-  }
-  function testScopeBoundary(source, localIdents, nodeCount, visitorTest) {
-    function visitor(traverse, node, path, state) {
-      var actualLocalIdents = Object.keys(state.localScope.identifiers);
-      expect(actualLocalIdents.sort()).toEqual(localIdents.sort());
-    }
-    visitor.test = visitorTest;
-    _runVisitor(source, nodeCount, visitor);
-  }
-  function testParentScope(source, parentIdents, nodeCount, visitorTest) {
-    function visitor(traverse, node, path, state) {
-      parentIdents = parentIdents && parentIdents.sort();
-      var parentScope = state.localScope.parentScope;
-      var actualParentIdents = parentScope && Object.keys(parentScope.identifiers).sort();
-      expect(actualParentIdents).toEqual(parentIdents);
-    }
-    visitor.test = visitorTest;
-    _runVisitor(source, nodeCount, visitor);
-  }
-  describe('closure scope boundaries', function() {
-    it('creates a scope boundary around Program scope', function() {
-      var source = 'var foo;' + 'var bar, baz;' + 'function blah() {}';
-      var idents = ['foo', 'bar', 'baz', 'blah'];
-      testScopeBoundary(source, idents, 3, function(node, path) {
-        return path[0] && path[0].type === Syntax.Program;
-      });
-    });
-    it('creates a scope boundary around FunctionDeclarations', function() {
-      var source = 'var foo;' + 'function blah() {' + '  var bar;' + '  function nested() {' + '    var baz;' + '  }' + '}';
-      var programIdents = ['foo', 'blah'];
-      var blahIdents = ['arguments', 'bar', 'nested'];
-      var nestedIdents = ['arguments', 'baz'];
-      testScopeBoundary(source, programIdents, 2, function(node, path) {
-        return path[0] && path[0].type === Syntax.Program;
-      });
-      testScopeBoundary(source, blahIdents, 2, function(node, path) {
-        return path[0] && path[0].type === Syntax.BlockStatement && path[1] && path[1].type === Syntax.FunctionDeclaration && path[1].id.name === 'blah';
-      });
-      testScopeBoundary(source, nestedIdents, 1, function(node, path) {
-        return path[0] && path[0].type === Syntax.BlockStatement && path[1] && path[1].type === Syntax.FunctionDeclaration && path[1].id.name === 'nested';
-      });
-    });
-    it('creates a scope boundary around MethodDefinitions', function() {
-      var source = 'var foo;' + 'class ClassA {' + '  blah() {' + '    var bar;' + '  }' + '  another() {' + '    var baz;' + '  }' + '}';
-      var programIdents = ['foo', 'ClassA'];
-      var blahIdents = ['arguments', 'bar'];
-      var anotherIdents = ['arguments', 'baz'];
-      testScopeBoundary(source, programIdents, 2, function(node, path) {
-        return path[0] && path[0].type === Syntax.Program;
-      });
-      testScopeBoundary(source, blahIdents, 1, function(node, path) {
-        return path[0] && path[0].type === Syntax.BlockStatement && path[1] && path[1].type === Syntax.FunctionExpression && path[2] && path[2].type === Syntax.MethodDefinition && path[2].key.name === 'blah';
-      });
-      testScopeBoundary(source, anotherIdents, 1, function(node, path) {
-        return path[0] && path[0].type === Syntax.BlockStatement && path[1] && path[1].type === Syntax.FunctionExpression && path[2] && path[2].type === Syntax.MethodDefinition && path[2].key.name === 'another';
-      });
-    });
-    it('creates a scope boundary around concise ArrowFunc exprs', function() {
-      var source = 'var foo;' + 'var bar = baz => baz;';
-      var programIdents = ['foo', 'bar'];
-      var barIdents = ['arguments', 'baz'];
-      testScopeBoundary(source, programIdents, 2, function(node, path) {
-        return path[0] && path[0].type === Syntax.Program;
-      });
-      testScopeBoundary(source, barIdents, 1, function(node, path) {
-        return path[0] && path[0].type === Syntax.ArrowFunctionExpression && path[0].body === node;
-      });
-    });
-    it('uses VariableDeclarations to determine scope boundary', function() {
-      var source = 'var foo = 1;' + 'function bar() {' + '  foo++;' + '  function baz() {' + '    var foo = 2;' + '  }' + '}';
-      var programIdents = ['foo', 'bar'];
-      var barIdents = ['arguments', 'baz'];
-      var bazIdents = ['arguments', 'foo'];
-      testScopeBoundary(source, programIdents, 2, function(node, path) {
-        return path[0] && path[0].type === Syntax.Program;
-      });
-      testScopeBoundary(source, barIdents, 2, function(node, path) {
-        return path[0] && path[0].type === Syntax.BlockStatement && path[1] && path[1].type === Syntax.FunctionDeclaration && path[1].id.name === 'bar';
-      });
-      testScopeBoundary(source, bazIdents, 1, function(node, path) {
-        return path[0] && path[0].type === Syntax.BlockStatement && path[1] && path[1].type === Syntax.FunctionDeclaration && path[1].id.name === 'baz';
-      });
-    });
-    it('includes function args in functions scope boundary', function() {
-      var source = 'var foo;' + 'function blah(bar) {' + '  var baz;' + '}' + 'var blah2 = bar2 => {var baz;};' + 'var blah3 = bar3 => bar3;';
-      var programIdents = ['foo', 'blah', 'blah2', 'blah3'];
-      var blahIdents = ['arguments', 'bar', 'baz'];
-      var blah2Idents = ['arguments', 'bar2', 'baz'];
-      var blah3Idents = ['arguments', 'bar3'];
-      testScopeBoundary(source, programIdents, 4, function(node, path) {
-        return path[0] && path[0].type === Syntax.Program;
-      });
-      testScopeBoundary(source, blahIdents, 1, function(node, path) {
-        return path[0] && path[0].type === Syntax.BlockStatement && path[1] && path[1].type === Syntax.FunctionDeclaration && path[1].id.name === 'blah';
-      });
-      testScopeBoundary(source, blah2Idents, 1, function(node, path) {
-        return path[0] && path[0].type === Syntax.BlockStatement && path[1] && path[1].type === Syntax.ArrowFunctionExpression && path[2].id.name === 'blah2';
-      });
-      testScopeBoundary(source, blah3Idents, 1, function(node, path) {
-        return path[0] && path[0].type === Syntax.ArrowFunctionExpression && path[0].body === node && path[1].id.name === 'blah3';
-      });
-    });
-    it('includes rest param args in function scope boundaries', function() {
-      var source = 'var foo;' + 'function blah(...bar) {' + '  var baz;' + '}' + 'var blah2 = (...bar2) => {var baz;};' + 'var blah3 = (...bar3) => bar3;';
-      var programIdents = ['foo', 'blah', 'blah2', 'blah3'];
-      var blahIdents = ['arguments', 'bar', 'baz'];
-      var blah2Idents = ['arguments', 'bar2', 'baz'];
-      var blah3Idents = ['arguments', 'bar3'];
-      testScopeBoundary(source, programIdents, 4, function(node, path) {
-        return path[0] && path[0].type === Syntax.Program;
-      });
-      testScopeBoundary(source, blahIdents, 1, function(node, path) {
-        return path[0] && path[0].type === Syntax.BlockStatement && path[1] && path[1].type === Syntax.FunctionDeclaration && path[1].id.name === 'blah';
-      });
-      testScopeBoundary(source, blah2Idents, 1, function(node, path) {
-        return path[0] && path[0].type === Syntax.BlockStatement && path[1] && path[1].type === Syntax.ArrowFunctionExpression && path[2].id.name === 'blah2';
-      });
-      testScopeBoundary(source, blah3Idents, 1, function(node, path) {
-        return path[0] && path[0].type === Syntax.ArrowFunctionExpression && path[0].body === node && path[1].id.name === 'blah3';
-      });
-    });
-    it('puts FunctionExpression names within function scope', function() {
-      var source = 'var foo;' + 'var bar = function baz() {' + '  var blah;' + '};';
-      var programIdents = ['foo', 'bar'];
-      var bazIdents = ['arguments', 'baz', 'blah'];
-      testScopeBoundary(source, programIdents, 2, function(node, path) {
-        return path[0] && path[0].type === Syntax.Program;
-      });
-      testScopeBoundary(source, bazIdents, 1, function(node, path) {
-        return path[0] && path[0].type === Syntax.BlockStatement && path[1] && path[1].type === Syntax.FunctionExpression && path[1].id.name === 'baz';
-      });
-    });
-  });
-  describe('block scope boundaries', function() {
-    it('creates a scope boundary around CatchClauses with params', function() {
-      var source = 'var blah = 0;' + 'try {' + '} catch (e) {' + '  blah++;' + '}';
-      var programIdents = ['blah'];
-      var catchIdents = ['e'];
-      testScopeBoundary(source, programIdents, 2, function(node, path) {
-        return path[0] && path[0].type === Syntax.Program;
-      });
-      testScopeBoundary(source, catchIdents, 1, function(node, path) {
-        return path[0] && path[0].type === Syntax.BlockStatement && path[1] && path[1].type === Syntax.CatchClause;
-      });
-    });
-    it('includes vars defined in CatchClauses in the parent scope', function() {
-      var source = 'try {' + '} catch (e) {' + '  var blah;' + '}';
-      var programIdents = ['blah'];
-      var catchIdents = ['e'];
-      testScopeBoundary(source, programIdents, 1, function(node, path) {
-        return path[0] && path[0].type === Syntax.Program;
-      });
-      testScopeBoundary(source, catchIdents, 1, function(node, path) {
-        return path[0] && path[0].type === Syntax.BlockStatement && path[1] && path[1].type === Syntax.CatchClause;
-      });
-    });
-  });
-  describe('scope chain linking', function() {
-    it('links parent scope boundaries', function() {
-      var source = 'var foo;' + 'function blah() {' + '  var bar;' + '  function nested() {' + '    var baz;' + '  }' + '}';
-      var programIdents = ['foo', 'blah'];
-      var blahIdents = ['arguments', 'bar', 'nested'];
-      testParentScope(source, programIdents, 2, function(node, path) {
-        return path[0] && path[0].type === Syntax.BlockStatement && path[1] && path[1].type === Syntax.FunctionDeclaration && path[1].id.name === 'blah';
-      });
-      testParentScope(source, blahIdents, 1, function(node, path) {
-        return path[0] && path[0].type === Syntax.BlockStatement && path[1] && path[1].type === Syntax.FunctionDeclaration && path[1].id.name === 'nested';
-      });
-    });
-    it('nests MethodDefinition boundaries under parent scope', function() {
-      var source = 'var foo;' + 'class ClassA {' + '  blah() {' + '    var bar;' + '  }' + '}';
-      var programIdents = ['foo', 'ClassA'];
-      testParentScope(source, programIdents, 1, function(node, path) {
-        return path[0] && path[0].type === Syntax.BlockStatement && path[1] && path[1].type === Syntax.FunctionExpression && path[2] && path[2].type === Syntax.MethodDefinition && path[2].key.name === 'blah';
-      });
-    });
-  });
-  describe('"use strict" tracking', function() {
-    function testStrictness(expectedStrict, source) {
-      var visitedNodes = 0;
-      function visitor(traverse, node, path, state) {
-        visitedNodes++;
-        expect(state.scopeIsStrict).toBe(expectedStrict);
-      }
-      visitor.test = function(node, path, state) {
-        return node.type === Syntax.Literal && node.value === 'testStr';
-      };
-      transformFn([visitor], source);
-      expect(visitedNodes).toBe(1);
-    }
-    it('detects program-level strictness', function() {
-      testStrictness(false, '"testStr";');
-      testStrictness(true, '"use strict"; "testStr";');
-    });
-    it('detects non-inherited strictness', function() {
-      testStrictness(true, ['function foo() {', '  "use strict";', '  "testStr";', '}'].join('\n'));
-    });
-    it('detects program-inherited strictness', function() {
-      testStrictness(true, ['"use strict";', 'function foo() {', '  "testStr";', '}'].join('\n'));
-    });
-    it('detects function-inherited strictness', function() {
-      testStrictness(true, ['function foo() {', '  "use strict";', '  function bar() {', '    "testStr";', '  }', '}'].join('\n'));
-    });
-    it('does not detect sibling strictness', function() {
-      testStrictness(false, ['function foo() {', '  "use strict";', '}', 'function bar() {', '  "testStr";', '}'].join('\n'));
-    });
-  });
-  describe('visitors', function() {
-    it('should visit nodes in order', function() {
-      var source = ['// Foo comment', 'function foo() {}', '', '// Bar comment', 'function bar() {}'].join('\n');
-      var actualNodes = [];
-      function visitFunction(traverse, node, path, state) {
-        actualNodes.push([node.id.name, node.range[0]]);
-      }
-      visitFunction.test = function(node, path, state) {
-        return node.type === Syntax.FunctionDeclaration;
-      };
-      function visitComments(traverse, node, path, state) {
-        actualNodes.push([node.value, node.range[0]]);
-      }
-      visitComments.test = function(node, path, state) {
-        return node.type === 'Line';
-      };
-      transformFn([visitComments, visitFunction], source);
-      expect(actualNodes).toEqual([[' Foo comment', 0], ['foo', 15], [' Bar comment', 34], ['bar', 49]]);
-    });
-  });
-});

data/public/vendor/npm/jstransform@10.1.0/src/__tests__/jstransform-utils-test.js

@@ -1,31 +0,0 @@
-/* */ 
-require("mock-modules").autoMockOff();
-describe('jstransform-utils', function() {
-  var transform,
-      utils;
-  var Syntax = require("esprima-fb").Syntax;
-  beforeEach(function() {
-    require("mock-modules").dumpCache();
-    transform = require("../jstransform").transform;
-    utils = require("../utils");
-  });
-  describe('temporary variables', function() {
-    it('should inject temporary variables at the start of functions', function() {
-      function visitFunctionBlock(traverse, node, path, state) {
-        utils.catchup(node.range[0] + 1, state);
-        var x = utils.injectTempVar(state);
-        var y = utils.injectTempVar(state);
-        traverse(node.body, path, state);
-        utils.append('return ' + x + ' + ' + y + ';', state);
-        utils.catchup(node.range[1], state);
-        return false;
-      }
-      visitFunctionBlock.test = function(node, path, state) {
-        var parentType = path.length && path[0].type;
-        return node.type === Syntax.BlockStatement && (parentType === Syntax.FunctionDeclaration || parentType === Syntax.FunctionExpression);
-      };
-      expect(transform([visitFunctionBlock], 'var x = function() {};').code).toEqual('var x = function() {var $__0, $__1;return $__0 + $__1;};');
-      expect(eval(transform([visitFunctionBlock], '2 + (function sum(x, y)\t{ $__0 = x; $__1 = y; }(3, 5))').code)).toEqual(10);
-    });
-  });
-});

data/public/vendor/npm/jstransform@10.1.0/src/docblock.js

@@ -1,86 +0,0 @@
-/**
- * Copyright 2013 Facebook, Inc.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-var docblockRe = /^\s*(\/\*\*(.|\r?\n)*?\*\/)/;
-var ltrimRe = /^\s*/;
-/**
- * @param {String} contents
- * @return {String}
- */
-function extract(contents) {
-  var match = contents.match(docblockRe);
-  if (match) {
-    return match[0].replace(ltrimRe, '') || '';
-  }
-  return '';
-}
-
-
-var commentStartRe = /^\/\*\*?/;
-var commentEndRe = /\*+\/$/;
-var wsRe = /[\t ]+/g;
-var stringStartRe = /(\r?\n|^) *\*/g;
-var multilineRe = /(?:^|\r?\n) *(@[^\r\n]*?) *\r?\n *([^@\r\n\s][^@\r\n]+?) *\r?\n/g;
-var propertyRe = /(?:^|\r?\n) *@(\S+) *([^\r\n]*)/g;
-
-/**
- * @param {String} contents
- * @return {Array}
- */
-function parse(docblock) {
-  docblock = docblock
-    .replace(commentStartRe, '')
-    .replace(commentEndRe, '')
-    .replace(wsRe, ' ')
-    .replace(stringStartRe, '$1');
-
-  // Normalize multi-line directives
-  var prev = '';
-  while (prev != docblock) {
-    prev = docblock;
-    docblock = docblock.replace(multilineRe, "\n$1 $2\n");
-  }
-  docblock = docblock.trim();
-
-  var result = [];
-  var match;
-  while (match = propertyRe.exec(docblock)) {
-    result.push([match[1], match[2]]);
-  }
-
-  return result;
-}
-
-/**
- * Same as parse but returns an object of prop: value instead of array of paris
- * If a property appers more than once the last one will be returned
- *
- * @param {String} contents
- * @return {Object}
- */
-function parseAsObject(docblock) {
-  var pairs = parse(docblock);
-  var result = {};
-  for (var i = 0; i < pairs.length; i++) {
-    result[pairs[i][0]] = pairs[i][1];
-  }
-  return result;
-}
-
-
-exports.extract = extract;
-exports.parse = parse;
-exports.parseAsObject = parseAsObject;

data/public/vendor/npm/jstransform@10.1.0/src/jstransform.js

@@ -1,180 +0,0 @@
-/* */ 
-"use strict";
-var esprima = require("esprima-fb");
-var utils = require("./utils");
-var getBoundaryNode = utils.getBoundaryNode;
-var declareIdentInScope = utils.declareIdentInLocalScope;
-var initScopeMetadata = utils.initScopeMetadata;
-var Syntax = esprima.Syntax;
-function _nodeIsClosureScopeBoundary(node, parentNode) {
-  if (node.type === Syntax.Program) {
-    return true;
-  }
-  var parentIsFunction = parentNode.type === Syntax.FunctionDeclaration || parentNode.type === Syntax.FunctionExpression || parentNode.type === Syntax.ArrowFunctionExpression;
-  var parentIsCurlylessArrowFunc = parentNode.type === Syntax.ArrowFunctionExpression && node === parentNode.body;
-  return parentIsFunction && (node.type === Syntax.BlockStatement || parentIsCurlylessArrowFunc);
-}
-function _nodeIsBlockScopeBoundary(node, parentNode) {
-  if (node.type === Syntax.Program) {
-    return false;
-  }
-  return node.type === Syntax.BlockStatement && parentNode.type === Syntax.CatchClause;
-}
-function traverse(node, path, state) {
-  var startIndex = null;
-  var parentNode = path[0];
-  if (!Array.isArray(node) && state.localScope.parentNode !== parentNode) {
-    if (_nodeIsClosureScopeBoundary(node, parentNode)) {
-      var scopeIsStrict = state.scopeIsStrict;
-      if (!scopeIsStrict && (node.type === Syntax.BlockStatement || node.type === Syntax.Program)) {
-        scopeIsStrict = node.body.length > 0 && node.body[0].type === Syntax.ExpressionStatement && node.body[0].expression.type === Syntax.Literal && node.body[0].expression.value === 'use strict';
-      }
-      if (node.type === Syntax.Program) {
-        startIndex = state.g.buffer.length;
-        state = utils.updateState(state, {scopeIsStrict: scopeIsStrict});
-      } else {
-        startIndex = state.g.buffer.length + 1;
-        state = utils.updateState(state, {
-          localScope: {
-            parentNode: parentNode,
-            parentScope: state.localScope,
-            identifiers: {},
-            tempVarIndex: 0,
-            tempVars: []
-          },
-          scopeIsStrict: scopeIsStrict
-        });
-        declareIdentInScope('arguments', initScopeMetadata(node), state);
-        if (parentNode.params.length > 0) {
-          var param;
-          var metadata = initScopeMetadata(parentNode, path.slice(1), path[0]);
-          for (var i = 0; i < parentNode.params.length; i++) {
-            param = parentNode.params[i];
-            if (param.type === Syntax.Identifier) {
-              declareIdentInScope(param.name, metadata, state);
-            }
-          }
-        }
-        if (parentNode.rest) {
-          var metadata = initScopeMetadata(parentNode, path.slice(1), path[0]);
-          declareIdentInScope(parentNode.rest.name, metadata, state);
-        }
-        if (parentNode.type === Syntax.FunctionExpression && parentNode.id) {
-          var metaData = initScopeMetadata(parentNode, path.parentNodeslice, parentNode);
-          declareIdentInScope(parentNode.id.name, metaData, state);
-        }
-      }
-      collectClosureIdentsAndTraverse(node, path, state);
-    }
-    if (_nodeIsBlockScopeBoundary(node, parentNode)) {
-      startIndex = state.g.buffer.length;
-      state = utils.updateState(state, {localScope: {
-          parentNode: parentNode,
-          parentScope: state.localScope,
-          identifiers: {},
-          tempVarIndex: 0,
-          tempVars: []
-        }});
-      if (parentNode.type === Syntax.CatchClause) {
-        var metadata = initScopeMetadata(parentNode, path.slice(1), parentNode);
-        declareIdentInScope(parentNode.param.name, metadata, state);
-      }
-      collectBlockIdentsAndTraverse(node, path, state);
-    }
-  }
-  function traverser(node, path, state) {
-    node.range && utils.catchup(node.range[0], state);
-    traverse(node, path, state);
-    node.range && utils.catchup(node.range[1], state);
-  }
-  utils.analyzeAndTraverse(walker, traverser, node, path, state);
-  if (startIndex !== null) {
-    utils.injectTempVarDeclarations(state, startIndex);
-  }
-}
-function collectClosureIdentsAndTraverse(node, path, state) {
-  utils.analyzeAndTraverse(visitLocalClosureIdentifiers, collectClosureIdentsAndTraverse, node, path, state);
-}
-function collectBlockIdentsAndTraverse(node, path, state) {
-  utils.analyzeAndTraverse(visitLocalBlockIdentifiers, collectBlockIdentsAndTraverse, node, path, state);
-}
-function visitLocalClosureIdentifiers(node, path, state) {
-  var metaData;
-  switch (node.type) {
-    case Syntax.ArrowFunctionExpression:
-    case Syntax.FunctionExpression:
-      return false;
-    case Syntax.ClassDeclaration:
-    case Syntax.ClassExpression:
-    case Syntax.FunctionDeclaration:
-      if (node.id) {
-        metaData = initScopeMetadata(getBoundaryNode(path), path.slice(), node);
-        declareIdentInScope(node.id.name, metaData, state);
-      }
-      return false;
-    case Syntax.VariableDeclarator:
-      if (path[0].kind === 'var') {
-        metaData = initScopeMetadata(getBoundaryNode(path), path.slice(), node);
-        declareIdentInScope(node.id.name, metaData, state);
-      }
-      break;
-  }
-}
-function visitLocalBlockIdentifiers(node, path, state) {
-  if (node.type === Syntax.CatchClause) {
-    return false;
-  }
-}
-function walker(node, path, state) {
-  var visitors = state.g.visitors;
-  for (var i = 0; i < visitors.length; i++) {
-    if (visitors[i].test(node, path, state)) {
-      return visitors[i](traverse, node, path, state);
-    }
-  }
-}
-var _astCache = {};
-function getAstForSource(source, options) {
-  if (_astCache[source] && !options.disableAstCache) {
-    return _astCache[source];
-  }
-  var ast = esprima.parse(source, {
-    comment: true,
-    loc: true,
-    range: true,
-    sourceType: options.sourceType
-  });
-  if (!options.disableAstCache) {
-    _astCache[source] = ast;
-  }
-  return ast;
-}
-function transform(visitors, source, options) {
-  options = options || {};
-  var ast;
-  try {
-    ast = getAstForSource(source, options);
-  } catch (e) {
-    e.message = 'Parse Error: ' + e.message;
-    throw e;
-  }
-  var state = utils.createState(source, ast, options);
-  state.g.visitors = visitors;
-  if (options.sourceMap) {
-    var SourceMapGenerator = require("source-map").SourceMapGenerator;
-    state.g.sourceMap = new SourceMapGenerator({file: options.filename || 'transformed.js'});
-  }
-  traverse(ast, [], state);
-  utils.catchup(source.length, state);
-  var ret = {
-    code: state.g.buffer,
-    extra: state.g.extra
-  };
-  if (options.sourceMap) {
-    ret.sourceMap = state.g.sourceMap;
-    ret.sourceMapFilename = options.filename || 'source.js';
-  }
-  return ret;
-}
-exports.transform = transform;
-exports.Syntax = Syntax;