sequenceserver 2.0.0 → 2.1.0

data/public/vendor/npm/jstransform@10.1.0/visitors/__tests__/es6-es7-object-integration-test.js

@@ -1,40 +0,0 @@
-/* */ 
-require("mock-modules").autoMockOff();
-describe('es6-es7-object-integration-test', function() {
-  var transformFn;
-  var visitors;
-  var x = 123456;
-  var z = 345678;
-  beforeEach(function() {
-    require("mock-modules").dumpCache();
-    transformFn = require("../../src/jstransform").transform;
-    var conciseMethodVisitors = require("../es6-object-concise-method-visitors").visitorList;
-    var shortObjectsVisitors = require("../es6-object-short-notation-visitors").visitorList;
-    var spreadPropertyVisitors = require("../es7-spread-property-visitors").visitorList;
-    visitors = spreadPropertyVisitors.concat(shortObjectsVisitors, conciseMethodVisitors);
-  });
-  function transform(code) {
-    return transformFn(visitors, code).code;
-  }
-  it('handles spread with concise methods and short notation', function() {
-    var code = 'var xyz = { ...x, y() { return 42; }, z }';
-    var objectAssignMock = jest.genMockFunction();
-    Object.assign = objectAssignMock;
-    eval(transform(code));
-    var assignCalls = objectAssignMock.mock.calls;
-    expect(assignCalls.length).toBe(1);
-    expect(assignCalls[0].length).toBe(3);
-    expect(assignCalls[0][0]).toEqual({});
-    expect(assignCalls[0][1]).toEqual(x);
-    var trailingObject = assignCalls[0][2];
-    expect(trailingObject.y()).toEqual(42);
-    expect(trailingObject.z).toEqual(z);
-  });
-  it('does not call assign when there are no spread properties', function() {
-    var code = 'var xyz = { x, y() { return 42 }, z }';
-    var objectAssignMock = jest.genMockFunction();
-    Object.assign = objectAssignMock;
-    eval(transform(code));
-    expect(objectAssignMock).not.toBeCalled();
-  });
-});

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

@@ -1,47 +0,0 @@
-/* */ 
-require("mock-modules").autoMockOff();
-describe('es6-object-concise-method-visitors', function() {
-  var transformFn;
-  var conciseMethodVisitors;
-  var restParamVisitors;
-  var visitors;
-  beforeEach(function() {
-    require("mock-modules").dumpCache();
-    conciseMethodVisitors = require("../es6-object-concise-method-visitors").visitorList;
-    restParamVisitors = require("../es6-rest-param-visitors").visitorList;
-    transformFn = require("../../src/jstransform").transform;
-    visitors = conciseMethodVisitors.concat(restParamVisitors);
-  });
-  function transform(code) {
-    return transformFn(visitors, code).code;
-  }
-  function expectTransform(code, result) {
-    expect(transform(code)).toEqual(result);
-  }
-  it('should transform concise method and return 42', function() {
-    var code = transform(['var foo = {', '  bar(x) {', '    return x;', '  }', '};'].join('\n'));
-    eval(code);
-    expect(foo.bar(42)).toEqual(42);
-  });
-  it('should transform concise method with literal property', function() {
-    var code = transform(['var foo = {', '  "bar 1"(x) {', '    return x;', '  }', '};'].join('\n'));
-    eval(code);
-    expect(foo['bar 1'](42)).toEqual(42);
-  });
-  it('should work with rest params', function() {
-    var code = transform(['({', '  init(x, ...rest) {', '    return rest.concat(x);', '  }', '}).init(1, 2, 3);'].join('\n'));
-    expect(eval(code)).toEqual([2, 3, 1]);
-  });
-  it('should transform concise methods', function() {
-    expectTransform('var foo = {bar() {}};', 'var foo = {bar:function() {}};');
-    expectTransform('({bar(x) { return {baz(y) {}}; }});', '({bar:function(x) { return {baz:function(y) {}}; }});');
-  });
-  it('should preserve generators', function() {
-    expectTransform('var foo = {*bar(x) {yield x;}};', 'var foo = {bar:function*(x) {yield x;}};');
-    expectTransform('var foo = {*"abc"(x) {yield x;}, *42(x) {yield x;}};', 'var foo = {"abc":function*(x) {yield x;}, 42:function*(x) {yield x;}};');
-    expectTransform('var foo = {*[a+b](x) {yield x;}}', 'var foo = {[a+b]:function*(x) {yield x;}}');
-  });
-  it('should handle reserved words', function() {
-    expectTransform('({delete(x) {}})', '({"delete":function(x) {}})');
-  });
-});

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

@@ -1,33 +0,0 @@
-/* */ 
-require("mock-modules").autoMockOff();
-describe('es6-object-short-notation-visitors', function() {
-  var transformFn;
-  var destructuringVisitors;
-  var shortObjectsVisitors;
-  var visitors;
-  beforeEach(function() {
-    require("mock-modules").dumpCache();
-    transformFn = require("../../src/jstransform").transform;
-    shortObjectsVisitors = require("../es6-object-short-notation-visitors").visitorList;
-    destructuringVisitors = require("../es6-destructuring-visitors").visitorList;
-    visitors = shortObjectsVisitors.concat(destructuringVisitors);
-  });
-  function transform(code) {
-    return transformFn(visitors, code).code;
-  }
-  function expectTransform(code, result) {
-    expect(transform(code)).toEqual(result);
-  }
-  it('should transform short notation and return 5', function() {
-    var code = transform(['(function(x, y) {', '  var data = {x, y};', '  return data.x + data.y;', '})(2, 3);'].join('\n'));
-    expect(eval(code)).toEqual(5);
-  });
-  it('should transform work with destructuring and return 10', function() {
-    var code = transform(['var x = 5, y = 5;', '(function({x, y}) {', '  var data = {x, y};', '  return data.x + data.y;', '})({x, y});'].join('\n'));
-    expect(eval(code)).toEqual(10);
-  });
-  it('should transform simple short notation', function() {
-    expectTransform('function foo(x, y) { return {x, y}; }', 'function foo(x, y) { return {x:x, y:y}; }');
-    expectTransform(['function', '', 'foo    (', '    x,', '          y', '', ')', '', '        {', ' return         {', '          x,', '  y};', '}'].join('\n'), ['function', '', 'foo    (', '    x,', '          y', '', ')', '', '        {', ' return         {', '          x:x,', '  y:y};', '}'].join('\n'));
-  });
-});

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

@@ -1,119 +0,0 @@
-/* */ 
-require("mock-modules").autoMockOff();
-describe('es6-rest-param-visitors', () => {
-  var transformFn;
-  var visitorSet;
-  var arrowFuncVisitors;
-  var classVisitors;
-  var restParamVisitors;
-  beforeEach(() => {
-    require("mock-modules").dumpCache();
-    arrowFuncVisitors = require("../es6-arrow-function-visitors").visitorList;
-    classVisitors = require("../es6-class-visitors").visitorList;
-    restParamVisitors = require("../es6-rest-param-visitors").visitorList;
-    transformFn = require("../../src/jstransform").transform;
-    visitorSet = arrowFuncVisitors.concat(classVisitors).concat(restParamVisitors);
-  });
-  function transform(code) {
-    return transformFn(visitorSet, code).code;
-  }
-  function expectTransform(code, result) {
-    expect(transform(code)).toEqual(result);
-  }
-  describe('function expressions', () => {
-    it('should capture 2 rest params, having 2 args', () => {
-      var code = transform(['(function(x, y, ...args) {', '  return [x, y, args.length, args[0], args[1]];', '})(1, 2, 3, 4);'].join('\n'));
-      expect(eval(code)).toEqual([1, 2, 2, 3, 4]);
-    });
-    it('should transform rest parameters in nested functions', () => {
-      var code = transform(['(function(x, ...args) {', '  return function(...params) {', '    return args.concat(params);', '  };', '})(1, 2, 3)(4, 5);'].join('\n'));
-      expect(eval(code)).toEqual([2, 3, 4, 5]);
-    });
-    it('should supply an array object', () => {
-      var code = transform(['(function(...args) {', '  return Array.isArray(args);', '})()'].join('\n'));
-      expect(eval(code)).toBe(true);
-    });
-  });
-  describe('function declarations', () => {
-    it('should capture 2 rest params, having 2 args', () => {
-      var code = transform(['function test(x, y, ...args) {', '  return [x, y, args.length, args[0], args[1]];', '}'].join('\n'));
-      eval(code);
-      expect(test(1, 2, 3, 4)).toEqual([1, 2, 2, 3, 4]);
-    });
-    it('should transform rest parameters in nested functions', () => {
-      var code = transform(['function testOuter(x, ...args) {', '  function testInner(...params) {', '    return args.concat(params);', '  }', '  return testInner;', '}'].join('\n'));
-      eval(code);
-      expect(testOuter(1, 2, 3)(4, 5)).toEqual([2, 3, 4, 5]);
-    });
-    it('should supply an array object', () => {
-      var code = transform(['function test(...args) {', '  return Array.isArray(args);', '}'].join('\n'));
-      eval(code);
-      expect(test()).toBe(true);
-    });
-  });
-  describe('arrow functions', () => {
-    it('should transform non-block bodied arrow functions', () => {
-      var code = transform(['var test = (...args) => args;'].join('\n'));
-      eval(code);
-      expect(test('foo', 'bar')).toEqual(['foo', 'bar']);
-    });
-    it('should capture 2 rest params, having 2 args', () => {
-      var code = transform(['var test = (x, y, ...args) => {', '  return [x, y, args.length, args[0], args[1]];', '}'].join('\n'));
-      eval(code);
-      expect(test(1, 2, 3, 4)).toEqual([1, 2, 2, 3, 4]);
-    });
-    it('should transform rest parameters in nested arrow functions', () => {
-      var code = transform(['var testOuter = (x, ...args) => {', '  var testInner = (...params) => {', '    return args.concat(params);', '  };', '  return testInner;', '};'].join('\n'));
-      eval(code);
-      expect(testOuter(1, 2, 3)(4, 5)).toEqual([2, 3, 4, 5]);
-    });
-    it('should supply an array object', () => {
-      var code = transform(['var test = (...args) => {', '  return Array.isArray(args);', '};'].join('\n'));
-      eval(code);
-      expect(test()).toBe(true);
-    });
-  });
-  describe('class methods', () => {
-    it('should capture 2 rest params, having 2 args', () => {
-      var code = transform(['class Foo {', '  constructor(x, y, ...args) {', '    this.ctor = [x, y, args.length, args[0], args[1]];', '  }', '  testMethod(x, y, ...args) {', '    return [x, y, args.length, args[0], args[1]];', '  }', '  static testMethod(x, y, ...args) {', '    return [x, y, args.length, args[0], args[1]];', '  }', '}'].join('\n'));
-      eval(code);
-      var fooInst = new Foo(1, 2, 3, 4);
-      expect(fooInst.ctor).toEqual([1, 2, 2, 3, 4]);
-      expect(fooInst.testMethod(1, 2, 3, 4)).toEqual([1, 2, 2, 3, 4]);
-      expect(Foo.testMethod(1, 2, 3, 4)).toEqual([1, 2, 2, 3, 4]);
-    });
-    it('should transform rest parameters in nested functions', () => {
-      var code = transform(['class Foo {', '  constructor(x, ...args) {', '    function inner(...params) {', '      return args.concat(params);', '    }', '    this.ctor = inner;', '  }', '  testMethod(x, ...args) {', '    function inner(...params) {', '      return args.concat(params);', '    }', '    return inner;', '  }', '  static testMethod(x, ...args) {', '    function inner(...params) {', '      return args.concat(params);', '    }', '    return inner;', '  }', '}'].join('\n'));
-      eval(code);
-      var fooInst = new Foo(1, 2, 3);
-      expect(fooInst.ctor(4, 5)).toEqual([2, 3, 4, 5]);
-      expect(fooInst.testMethod(1, 2, 3)(4, 5)).toEqual([2, 3, 4, 5]);
-      expect(Foo.testMethod(1, 2, 3)(4, 5)).toEqual([2, 3, 4, 5]);
-    });
-    it('should supply an array object', () => {
-      var code = transform(['class Foo {', '  constructor(...args) {', '    this.ctor = Array.isArray(args);', '  }', '  testMethod(...args) {', '    return Array.isArray(args);', '  }', '  static testMethod(...args) {', '    return Array.isArray(args);', '  }', '}'].join('\n'));
-      eval(code);
-      var fooInst = new Foo();
-      expect(fooInst.ctor).toBe(true);
-      expect(fooInst.testMethod()).toBe(true);
-      expect(Foo.testMethod()).toBe(true);
-    });
-  });
-  describe('whitespace preservation', () => {
-    it('1-line function decl with 2 args', () => {
-      expectTransform('function foo(x, y, ...args) { return x + y + args[0]; }', 'function foo(x, y ) {for (var args=[],$__0=2,$__1=arguments.length;' + '$__0<$__1;$__0++) args.push(arguments[$__0]); return x + y + ' + 'args[0]; }');
-    });
-    it('1-line function expression with 1 arg', () => {
-      expectTransform('(function(x, ...args) { return args;});', '(function(x ) {for (var args=[],$__0=1,$__1=arguments.length;' + '$__0<$__1;$__0++) args.push(arguments[$__0]); return args;});');
-    });
-    it('1-line function expression with no args', () => {
-      expectTransform('map(function(...args) { return args.map(log); });', 'map(function() {for (var args=[],$__0=0,$__1=arguments.length;' + '$__0<$__1;$__0++) args.push(arguments[$__0]); ' + 'return args.map(log); });');
-    });
-    it('preserves lines for ugly code', () => {
-      expectTransform(['function', '', 'foo    (', '    x,', '          ...args', '', ')', '', '        {', ' return         args;', '}'].join('\n'), ['function', '', 'foo    (', '    x', '          ', '', ')', '', '        {for (var args=[],$__0=1,$__1=arguments.length;$__0<$__1;' + '$__0++) args.push(arguments[$__0]);', ' return         args;', '}'].join('\n'));
-    });
-    it('preserves inline comments', () => {
-      expectTransform('function foo(/*string*/foo, /*bool*/bar, ...args) { return args; }', 'function foo(/*string*/foo, /*bool*/bar ) {' + 'for (var args=[],$__0=2,$__1=arguments.length;$__0<$__1;$__0++) ' + 'args.push(arguments[$__0]); ' + 'return args; ' + '}');
-    });
-  });
-});

data/public/vendor/npm/jstransform@10.1.0/visitors/__tests__/es6-template-visitors-test.js

@@ -1,138 +0,0 @@
-/* */ 
-require("mock-modules").autoMockOff();
-describe('ES6 Template Visitor', function() {
-  var transformFn;
-  var visitors;
-  beforeEach(function() {
-    require("mock-modules").dumpCache();
-    visitors = require("../es6-template-visitors").visitorList;
-    transformFn = require("../../src/jstransform").transform;
-  });
-  function transform(code) {
-    return transformFn(visitors, code).code;
-  }
-  function expectTransform(code, result) {
-    expect(transform(code)).toEqual(result);
-  }
-  function expectEval(code, result, setupFn) {
-    var actual;
-    if (setupFn) {
-      eval(setupFn);
-    }
-    eval('actual = ' + transform(code));
-    expect(actual).toEqual(result);
-  }
-  function expectEvalTag(code, tagFn, scope) {
-    if (scope) {
-      Object.keys(scope).forEach((key) => this[key] = scope[key]);
-    }
-    var tagCalls = 0;
-    var tag = function(...args) {
-      tagCalls++;
-      return tagFn.apply(this, args);
-    };
-    var result = transform(code);
-    expect(result.split('\n').length).toBe(code.split('\n').length);
-    eval(result);
-    expect(tagCalls).toBe(1);
-  }
-  function expectSiteObj(siteObj, cooked, raw) {
-    expect(Array.isArray(siteObj)).toBe(true);
-    expect(Object.isFrozen(siteObj)).toBe(true);
-    expect(Array.isArray(siteObj.raw)).toBe(true);
-    expect(Object.isFrozen(siteObj.raw)).toBe(true);
-    expect(siteObj.length).toBe(cooked.length);
-    expect(siteObj.raw.length).toBe(raw.length);
-    for (var ii = 0; ii < cooked.length; ii++) {
-      expect(siteObj[ii]).toEqual(cooked[ii]);
-    }
-    expect(siteObj.raw).toEqual(raw);
-  }
-  it('should transform simple literals', function() {
-    expectTransform('`foo bar`', '("foo bar")');
-    expectEval('`foo bar`', 'foo bar');
-    expectEval('`$`', '$');
-    expectEval('`$foo`', '$foo');
-  });
-  it('should properly escape templates containing quotes', function() {
-    expectTransform('`foo "bar"`', '("foo \\"bar\\"")');
-    expectEval('`foo "bar"`', 'foo "bar"');
-    expectTransform("`foo 'bar'`", '("foo \'bar\'")');
-    expectEval("`foo 'bar'`", "foo 'bar'");
-    expectTransform('`foo \\\\"bar\\\\"`', '("foo \\\\\\"bar\\\\\\"")');
-    expectEval('`foo \\\\\\"bar\\\\\\"`', 'foo \\"bar\\"');
-  });
-  it('should transform simple substitutions', function() {
-    expectTransform('`foo ${bar}`', '("foo " + bar)');
-    expectTransform('`${foo} bar`', '(foo + " bar")');
-    expectTransform('`${foo} ${bar}`', '(foo + " " + bar)');
-    expectTransform('`${foo}${bar}`', '(foo + bar)');
-  });
-  it('should transform expressions', function() {
-    expectTransform('`foo ${bar()}`', '("foo " + bar())');
-    expectTransform('`foo ${bar.baz}`', '("foo " + bar.baz)');
-    expectTransform('`foo ${bar + 5}`', '("foo " + (bar + 5))');
-    expectTransform('`${foo + 5} bar`', '((foo + 5) + " bar")');
-    expectTransform('`${foo + 5} ${bar}`', '((foo + 5) + " " + bar)');
-    expectTransform('`${(function(b) {alert(4);})(a)}`', '((function(b) {alert(4);})(a))');
-  });
-  it('should transform tags with simple templates', function() {
-    var tag = function(elements) {
-      expectSiteObj(elements, ['foo bar'], ['foo bar']);
-    };
-    var result = transform("tag`foo bar`");
-    expect(result.split('\n').length).toBe(1);
-    eval(result);
-    var a = {b: tag};
-    eval(transform("a.b`foo bar`"));
-    eval(transform("a['b']`foo bar`"));
-    var getTag = function() {
-      return tag;
-    };
-    eval(transform("getTag()`foo bar`"));
-    eval(transform("(getTag())`foo bar`"));
-  });
-  it('should transform tags with substitutions', function() {
-    expectTransform("tag`foo ${bar} baz`", 'tag(function() { var siteObj = ["foo ", " baz"]; ' + 'siteObj.raw = ["foo ", " baz"]; Object.freeze(siteObj.raw); ' + 'Object.freeze(siteObj); return siteObj; }(), bar)');
-    expectEvalTag("tag`foo ${bar + 'abc'} baz`", function(elements, ...args) {
-      expectSiteObj(elements, ['foo ', ' baz'], ['foo ', ' baz']);
-      expect(args.length).toBe(1);
-      expect(args[0]).toBe('barabc');
-    }, {bar: 'bar'});
-    expectEvalTag("tag`foo ${bar + 'abc'}`", function(elements, ...args) {
-      expectSiteObj(elements, ['foo ', ''], ['foo ', '']);
-      expect(args.length).toBe(1);
-      expect(args[0]).toBe('barabc');
-    }, {bar: 'bar'});
-    expectEvalTag("tag`foo\n\n\nbar`", (elements) => {
-      expectSiteObj(elements, ['foo\n\n\nbar'], ['foo\n\n\nbar']);
-    });
-    expectEvalTag("tag`a\nb\n${c}\nd`", (elements, ...args) => {
-      expectSiteObj(elements, ['a\nb\n', '\nd'], ['a\nb\n', '\nd']);
-      expect(args.length).toBe(1);
-      expect(args[0]).toBe('c');
-    }, {c: 'c'});
-  });
-  it('should maintain line numbers', function() {
-    expectTransform("`foo\n\nbar`", '("foo\\n\\nbar"\n\n)');
-    expectTransform("`foo\n${bar}\nbaz`", '("foo\\n" + \nbar + "\\nbaz"\n)');
-    expectTransform("`foo\\nbar`", '("foo\\nbar")');
-    expectTransform("tag`a\nb\n${c}${d}\ne`", 'tag(function() { var siteObj = ["a\\nb\\n", "", "\\ne"]; ' + 'siteObj.raw = ["a\\nb\\n", "", "\\ne"]; Object.freeze(siteObj.raw); ' + 'Object.freeze(siteObj); return siteObj; }(), \n\nc, d\n)');
-  });
-  it('should handle multiple lines', function() {
-    expectEval("`foo\n\nbar`", 'foo\n\nbar');
-    expectEval("`foo\\nbar`", 'foo\nbar');
-    expectEval("`foo\\\\nbar`", 'foo\\nbar');
-    expectEval("`foo\n${bar}\nbaz`", 'foo\nabc\nbaz', 'var bar = "abc";');
-  });
-  it('should canonicalize line endings', function() {
-    expectTransform("`foo\r\nbar`", '("foo\\nbar"\n)');
-    expectTransform("`foo\rbar`", '("foo\\nbar")');
-    expectEval("`foo\r\nbar`", 'foo\nbar');
-    expectEval("`foo\rbar`", 'foo\nbar');
-    expectEval("`foo\r\n${bar}\r\nbaz`", 'foo\nabc\nbaz', 'var bar = "abc";');
-    expectEvalTag("tag`foo\rbar`", (elements) => {
-      expectSiteObj(elements, ['foo\nbar'], ['foo\rbar']);
-    });
-  });
-});

data/public/vendor/npm/jstransform@10.1.0/visitors/__tests__/es7-rest-property-helpers-test.js

@@ -1,47 +0,0 @@
-/* */ 
-require("mock-modules").autoMockOff();
-describe('es7-rest-property-visitors', function() {
-  var transformFn;
-  var visitors;
-  beforeEach(function() {
-    require("mock-modules").dumpCache();
-    transformFn = require("../../src/jstransform").transform;
-    visitors = require("../es6-destructuring-visitors").visitorList;
-  });
-  function transform(code) {
-    var lines = Array.prototype.join.call(arguments, '\n');
-    return transformFn(visitors, lines).code;
-  }
-  it('picks off remaining properties from an object', function() {
-    var code = transform('({ x, y, ...z } = { x: 1, y: 2, a: 3, b: 4 });', '([ x, y, z ]);');
-    expect(eval(code)).toEqual([1, 2, {
-      a: 3,
-      b: 4
-    }]);
-  });
-  it('picks off remaining properties from a nested object', function() {
-    var code = transform('var complex = {', '  x: { a: 1, b: 2, c: 3 },', '  y: [4, 5, 6]', '};', 'var {', '  x: { a: xa, ...xbc },', '  y: [y0, ...y12]', '} = complex;', '([ xa, xbc, y0, y12 ]);');
-    expect(eval(code)).toEqual([1, {
-      b: 2,
-      c: 3
-    }, 4, [5, 6]]);
-  });
-  it('only extracts own properties', function() {
-    var code = transform('var obj = Object.create({ x: 1 });', 'obj.y = 2;', '({ ...y } = obj);', '(y);');
-    expect(eval(code)).toEqual({y: 2});
-  });
-  it('only extracts own properties, except when they are explicit', function() {
-    var code = transform('var obj = Object.create({ x: 1, y: 2 });', 'obj.z = 3;', '({ y, ...z } = obj);', '([ y, z ]);');
-    expect(eval(code)).toEqual([2, {z: 3}]);
-  });
-  it('avoids passing extra properties when they are picked off', function() {
-    var code = transform('function base({ a, b, x }) { return [ a, b, x ]; }', 'function wrapper({ x, y, ...restConfig }) {', '  return base(restConfig);', '}', 'wrapper({ x: 1, y: 2, a: 3, b: 4 });');
-    expect(eval(code)).toEqual([3, 4, undefined]);
-  });
-  it('throws on leading rest properties', function() {
-    expect(() => transform('({ ...x, y, z } = obj)')).toThrow();
-  });
-  it('throws on multiple rest properties', function() {
-    expect(() => transform('({ x, ...y, ...z } = obj)')).toThrow();
-  });
-});

data/public/vendor/npm/jstransform@10.1.0/visitors/__tests__/es7-spread-property-visitors-test.js

@@ -1,90 +0,0 @@
-/* */ 
-require("mock-modules").autoMockOff();
-describe('es7-spread-property-visitors', function() {
-  var transformFn;
-  var originalAssign = Object.assign;
-  var visitors;
-  var x = 123456;
-  var y = 789012;
-  var z = 345678;
-  beforeEach(function() {
-    require("mock-modules").dumpCache();
-    transformFn = require("../../src/jstransform").transform;
-    visitors = require("../es7-spread-property-visitors").visitorList;
-  });
-  function transform(code) {
-    return transformFn(visitors, code).code;
-  }
-  function expectTransform(code, result) {
-    expect(transform(code)).toEqual(result);
-  }
-  function expectObjectAssign(code) {
-    var objectAssignMock = jest.genMockFunction();
-    Object.assign = objectAssignMock;
-    eval(transform(code));
-    return expect(objectAssignMock);
-  }
-  afterEach(function() {
-    Object.assign = originalAssign;
-  });
-  it('has access to a working Object.assign implementation', function() {
-    expect(typeof Object.assign).toBe('function');
-    expect(Object.assign({b: 2}, null, {a: 1})).toEqual({
-      a: 1,
-      b: 2
-    });
-  });
-  it('uses Object.assign with an empty new target object', function() {
-    expectObjectAssign('var xy = { ...x, y: 2 }').toBeCalledWith({}, x, {y: 2});
-  });
-  it('coalesces consecutive properties into a single object', function() {
-    expectObjectAssign('var xyz = { ...x, y: 2, z: z }').toBeCalledWith({}, x, {
-      y: 2,
-      z: z
-    });
-  });
-  it('avoids an unnecessary empty object when spread is not first', function() {
-    expectObjectAssign('var xy = { x: 1, ...y }').toBeCalledWith({x: 1}, y);
-  });
-  it('passes the same value multiple times to Object.assign', function() {
-    expectObjectAssign('var xyz = { x: 1, y: 2, ...z, ...z }').toBeCalledWith({
-      x: 1,
-      y: 2
-    }, z, z);
-  });
-  it('keeps object literals as separate arguments to assign', function() {
-    expectObjectAssign('var xyz = { x: 1, ...({ y: 2 }), z: 3 }').toBeCalledWith({x: 1}, {y: 2}, {z: 3});
-  });
-  it('does not call assign when there are no spread properties', function() {
-    expectObjectAssign('var xy = { x: 1, y: 2 }').not.toBeCalled();
-  });
-  it('should preserve extra whitespace', function() {
-    expectTransform('let xyz = { x: 1, y : \n 2, ... \nz,  ...  z   }', 'let xyz = Object.assign({ x: 1, y : \n 2},  \nz,    z   )');
-  });
-  it('should preserve parenthesis', function() {
-    expectTransform('let xyz = { x: 1, ...({ y: 2 }), z: 3 }', 'let xyz = Object.assign({ x: 1}, ({ y: 2 }), {z: 3 })');
-  });
-  it('should remove trailing commas after properties', function() {
-    expectTransform('let xyz = { ...x, y: 1, }', 'let xyz = Object.assign({}, x, {y: 1 })');
-  });
-  it('should remove trailing commas after spread', function() {
-    expectTransform('let xyz = { x: 1, ...y, }', 'let xyz = Object.assign({ x: 1}, y )');
-  });
-  it('should not transform destructuring assignment', function() {
-    expectTransform('let { x, ...y } = z', 'let { x, ...y } = z');
-  });
-  it('should not transform when there are getters', function() {
-    expectTransform('let xy = { ...x, get x() { } }', 'let xy = { ...x, get x() { } }');
-  });
-  it('should not transform when there are setters', function() {
-    expectTransform('let xy = { set x(v) { }, ...y }', 'let xy = { set x(v) { }, ...y }');
-  });
-  it('should silently ignore falsy values', function() {
-    var code = transform(['var x = null;', 'var y = { y: "y" };', 'var obj = { ...x, ...y, ...{ ...false, z: "z", ...y } };'].join('\n'));
-    eval(code);
-    expect(obj).toEqual({
-      y: 'y',
-      z: 'z'
-    });
-  });
-});

data/public/vendor/npm/jstransform@10.1.0/visitors/__tests__/gen/generate-type-syntax-test.js

@@ -1,40 +0,0 @@
-/* */ 
-var tests = require("../type-syntax-test");
-var jstransform = require("../../../src/jstransform");
-var visitors = require("../../type-syntax").visitorList;
-var fs = require("fs");
-var out = "/*\n";
-out += "* WARNING: This file is autogenerated by visitors/__tests__/gen/generate-type-syntax-test.js\n";
-out += "* Do NOT modify this file directly! Instead, add your tests to \n";
-out += "* visitors/__tests__/type-syntax-test.js and run visitors/__tests__/gen/generate-type-syntax-test.js\n";
-out += "*/\n\n";
-function escape_content(content) {
-  return content.replace(/[\\]/g, '\\\\').replace(/[\b]/g, '\\b').replace(/[\f]/g, '\\f').replace(/[\n]/g, '\\n').replace(/[\r]/g, '\\r').replace(/[\t]/g, '\\t').replace(/[']/g, "\\'");
-}
-out += "module.exports = {\n";
-for (var section in tests) {
-  out += "    '" + section + "': {\n";
-  for (var test in tests[section]) {
-    test = tests[section][test];
-    out += "        '" + escape_content(test) + "': {\n";
-    try {
-      var transformed = jstransform.transform(visitors, test).code;
-      out += "            raworiginal: '" + escape_content(test) + "',\n";
-      out += "            transformed: '" + escape_content(transformed) + "',\n";
-      try {
-        eval(transformed);
-        out += "            eval: 'No error',\n";
-      } catch (e) {
-        out += "            eval: '" + e.message + "',\n";
-      }
-    } catch (e) {
-      out += "            error: '" + e.message + "',\n";
-    }
-    out += "\n";
-    out += "        },\n";
-  }
-  out += "    },\n";
-}
-out += "};\n";
-fs.writeFileSync(__dirname + '/type-syntax-test.rec.js', out);
-console.log("Recorded type-syntax-test.js output into type-syntax-test.rec.js");