diff --git a/tests/JavaScriptTest.js b/tests/JavaScriptTest.js
index 2d7afc5..f1fdc69 100644
--- a/tests/JavaScriptTest.js
+++ b/tests/JavaScriptTest.js
@@ -1,13 +1,14 @@
 // Run this using JavaScriptTest.sh
-var assert = require('assert');
-var fs = require('fs');
+import assert from 'assert'
+import fs from 'fs'
+import * as flatbuffers from 'flatbuffers'
 
-var flatbuffers = require('../js/flatbuffers').flatbuffers;
-global.flatbuffers = flatbuffers;
-
-var MyGame = require(process.argv[2]).MyGame;
-
-var isTsTest = !!process.env.FB_TS_TEST; 
+import { Monster, MonsterT } from './my-game/example/monster'
+import { Test } from './my-game/example/test'
+import { Stat } from './my-game/example/stat'
+import { Vec3 } from './my-game/example/vec3'
+import { Color } from './my-game/example/color';
+import { Any } from './my-game/example/any';
 
 function main() {
 
@@ -27,11 +28,8 @@
   var fbb = new flatbuffers.Builder(1);
   createMonster(fbb);
   serializeAndTest(fbb);
+  testObjApiPack(fbb);
 
-  if(isTsTest) {
-    testObjApiPack(fbb);
-  }
-  
   // clear the builder, repeat tests
   var clearIterations = 100;
   var startingCapacity = fbb.bb.capacity();
@@ -39,10 +37,7 @@
     fbb.clear();
     createMonster(fbb);
     serializeAndTest(fbb);
-
-    if(isTsTest) {
-      testObjApiPack(fbb);
-    }
+    testObjApiPack(fbb);
   }
   // the capacity of our buffer shouldn't increase with the same size payload
   assert.strictEqual(fbb.bb.capacity(), startingCapacity);
@@ -52,7 +47,7 @@
   fuzzTest1();
   testNullStrings();
   testSharedStrings();
-  
+
   console.log('FlatBuffers test: completed successfully');
 }
 
@@ -61,36 +56,42 @@
 
   var str = fbb.createString('MyMonster');
 
-  var inv = MyGame.Example.Monster.createInventoryVector(fbb, [0, 1, 2, 3, 4]);
+  var inv = Monster.createInventoryVector(fbb, [0, 1, 2, 3, 4]);
 
   var fred = fbb.createString('Fred');
-  MyGame.Example.Monster.startMonster(fbb);
-  MyGame.Example.Monster.addName(fbb, fred);
-  var mon2 = MyGame.Example.Monster.endMonster(fbb);
+  Monster.startMonster(fbb);
+  Monster.addName(fbb, fred);
+  var mon2 = Monster.endMonster(fbb);
 
-  MyGame.Example.Monster.startTest4Vector(fbb, 2);
-  MyGame.Example.Test.createTest(fbb, 10, 20);
-  MyGame.Example.Test.createTest(fbb, 30, 40);
+  Monster.startTest4Vector(fbb, 2);
+  Test.createTest(fbb, 10, 20);
+  Test.createTest(fbb, 30, 40);
   var test4 = fbb.endVector();
 
-  var testArrayOfString = MyGame.Example.Monster.createTestarrayofstringVector(fbb, [
+  var testArrayOfString = Monster.createTestarrayofstringVector(fbb, [
     fbb.createString('test1'),
     fbb.createString('test2')
   ]);
 
-  MyGame.Example.Monster.startMonster(fbb);
-  MyGame.Example.Monster.addPos(fbb, MyGame.Example.Vec3.createVec3(fbb, 1, 2, 3, 3, MyGame.Example.Color.Green, 5, 6));
-  MyGame.Example.Monster.addHp(fbb, 80);
-  MyGame.Example.Monster.addName(fbb, str);
-  MyGame.Example.Monster.addInventory(fbb, inv);
-  MyGame.Example.Monster.addTestType(fbb, MyGame.Example.Any.Monster);
-  MyGame.Example.Monster.addTest(fbb, mon2);
-  MyGame.Example.Monster.addTest4(fbb, test4);
-  MyGame.Example.Monster.addTestarrayofstring(fbb, testArrayOfString);
-  MyGame.Example.Monster.addTestbool(fbb, true);
-  var mon = MyGame.Example.Monster.endMonster(fbb);
+  var testVectorOfLongs = Monster.createVectorOfLongsVector(fbb, [
+    1n,
+    101010100n
+  ]);
 
-  MyGame.Example.Monster.finishMonsterBuffer(fbb, mon);
+  Monster.startMonster(fbb);
+  Monster.addPos(fbb, Vec3.createVec3(fbb, 1, 2, 3, 3, Color.Green, 5, 6));
+  Monster.addHp(fbb, 80);
+  Monster.addName(fbb, str);
+  Monster.addInventory(fbb, inv);
+  Monster.addTestType(fbb, Any.Monster);
+  Monster.addTest(fbb, mon2);
+  Monster.addTest4(fbb, test4);
+  Monster.addTestarrayofstring(fbb, testArrayOfString);
+  Monster.addVectorOfLongs(fbb, testVectorOfLongs);
+  Monster.addTestbool(fbb, true);
+  var mon = Monster.endMonster(fbb);
+
+  Monster.finishMonsterBuffer(fbb, mon);
 }
 
 function serializeAndTest(fbb) {
@@ -99,7 +100,7 @@
   // parser may serialize in a slightly different order than the above
   // JavaScript code. They are functionally equivalent though.
 
-  fs.writeFileSync('monsterdata_javascript_wire.mon', new Buffer(fbb.asUint8Array()));
+  fs.writeFileSync('monsterdata_javascript_wire.mon', Buffer.from(fbb.asUint8Array()));
 
   // Tests mutation first.  This will verify that we did not trample any other
   // part of the byte buffer.
@@ -109,7 +110,7 @@
 }
 
 function testMutation(bb) {
-  var monster = MyGame.Example.Monster.getRootAsMonster(bb);
+  var monster = Monster.getRootAsMonster(bb);
 
   monster.mutate_hp(120);
   assert.strictEqual(monster.hp(), 120);
@@ -126,9 +127,9 @@
 function testObjApiPack(fbb) {
   fbb.clear();
   createMonster(fbb);
-  let monster_t = MyGame.Example.Monster.getRootAsMonster(fbb.dataBuffer()).unpack();
+  let monster_t = Monster.getRootAsMonster(fbb.dataBuffer()).unpack();
   fbb.clear();
-  MyGame.Example.Monster.finishMonsterBuffer(fbb, monster_t.pack(fbb));
+  Monster.finishMonsterBuffer(fbb, monster_t.pack(fbb));
   serializeAndTest(fbb);
 }
 
@@ -143,15 +144,15 @@
   assert.strictEqual(pos.y, 2);
   assert.strictEqual(pos.z, 3);
   assert.strictEqual(pos.test1, 3);
-  assert.strictEqual(pos.test2, MyGame.Example.Color.Green);
+  assert.strictEqual(pos.test2, Color.Green);
   let test3 = pos.test3;
   assert.strictEqual(test3.a, 5);
   assert.strictEqual(test3.b, 6);
 
-  assert.strictEqual(monster.testType, MyGame.Example.Any.Monster);
+  assert.strictEqual(monster.testType, Any.Monster);
   let monster2 = monster.test;
   assert.strictEqual(monster2 != null, true);
-  assert.strictEqual(monster2 instanceof MyGame.Example.MonsterT, true);
+  assert.strictEqual(monster2 instanceof MonsterT, true);
   assert.strictEqual(monster2.name, 'Fred');
 
   assert.strictEqual(monster.inventory.length, 5);
@@ -174,9 +175,9 @@
 }
 
 function testBuffer(bb) {
-  assert.ok(MyGame.Example.Monster.bufferHasIdentifier(bb));
+  assert.ok(Monster.bufferHasIdentifier(bb));
 
-  var monster = MyGame.Example.Monster.getRootAsMonster(bb);
+  var monster = Monster.getRootAsMonster(bb);
 
   assert.strictEqual(monster.hp(), 80);
   assert.strictEqual(monster.mana(), 150); // default
@@ -188,13 +189,13 @@
   assert.strictEqual(pos.y(), 2);
   assert.strictEqual(pos.z(), 3);
   assert.strictEqual(pos.test1(), 3);
-  assert.strictEqual(pos.test2(), MyGame.Example.Color.Green);
+  assert.strictEqual(pos.test2(), Color.Green);
   var t = pos.test3();
   assert.strictEqual(t.a(), 5);
   assert.strictEqual(t.b(), 6);
 
-  assert.strictEqual(monster.testType(), MyGame.Example.Any.Monster);
-  var monster2 = new MyGame.Example.Monster();
+  assert.strictEqual(monster.testType(), Any.Monster);
+  var monster2 = new Monster();
   assert.strictEqual(monster.test(monster2) != null, true);
   assert.strictEqual(monster2.name(), 'Fred');
 
@@ -212,6 +213,12 @@
   }
   assert.strictEqual(invsum2, 10);
 
+  let longSum = 0n;
+  for (let idx = 0; idx < monster.vectorOfLongsLength(); ++idx) {
+    longSum += monster.vectorOfLongs(idx);
+  }
+  assert.strictEqual(longSum, 101010101n);
+
   var test_0 = monster.test4(0);
   var test_1 = monster.test4(1);
   assert.strictEqual(monster.test4Length(), 2);
@@ -223,60 +230,57 @@
 
   assert.strictEqual(monster.testbool(), true);
 
-  if(isTsTest) {
-    let monster_t = monster.unpack();
-    testObjApiUnpack(monster_t);
+  let monster_t = monster.unpack();
+  testObjApiUnpack(monster_t);
 
-    let monster2_t = new MyGame.Example.MonsterT();
-    monster.unpackTo(monster2_t);
-    testObjApiUnpack(monster2_t);
-  }
+  let monster2_t = new MonsterT();
+  monster.unpackTo(monster2_t);
+  testObjApiUnpack(monster2_t);
 }
 
 function test64bit() {
   var fbb = new flatbuffers.Builder();
   var required = fbb.createString('required');
 
-  MyGame.Example.Stat.startStat(fbb);
-  var stat2 = MyGame.Example.Stat.endStat(fbb);
+  Stat.startStat(fbb);
+  var stat2 = Stat.endStat(fbb);
 
-  MyGame.Example.Monster.startMonster(fbb);
-  MyGame.Example.Monster.addName(fbb, required);
-  MyGame.Example.Monster.addTestempty(fbb, stat2);
-  var mon2 = MyGame.Example.Monster.endMonster(fbb);
+  Monster.startMonster(fbb);
+  Monster.addName(fbb, required);
+  Monster.addTestempty(fbb, stat2);
+  var mon2 = Monster.endMonster(fbb);
 
-  MyGame.Example.Stat.startStat(fbb);
-  // 2541551405100253985 = 0x87654321(low part) + 0x23456789 * 0x100000000(high part);
-  MyGame.Example.Stat.addVal(fbb, new flatbuffers.Long(0x87654321, 0x23456789));    // the low part is Uint32
-  var stat = MyGame.Example.Stat.endStat(fbb);
+  Stat.startStat(fbb);
+  // 2541551405100253985 = 0x2345678987654321
+  Stat.addVal(fbb, 0x2345678987654321n);
+  var stat = Stat.endStat(fbb);
 
-  MyGame.Example.Monster.startMonster(fbb);
-  MyGame.Example.Monster.addName(fbb, required);
-  MyGame.Example.Monster.addEnemy(fbb, mon2);
-  MyGame.Example.Monster.addTestempty(fbb, stat);
-  var mon = MyGame.Example.Monster.endMonster(fbb);
+  Monster.startMonster(fbb);
+  Monster.addName(fbb, required);
+  Monster.addEnemy(fbb, mon2);
+  Monster.addTestempty(fbb, stat);
+  var mon = Monster.endMonster(fbb);
 
-  MyGame.Example.Monster.finishMonsterBuffer(fbb, mon);
+  Monster.finishMonsterBuffer(fbb, mon);
   var bytes = fbb.asUint8Array();
 
   ////////////////////////////////////////////////////////////////
 
   var bb = new flatbuffers.ByteBuffer(bytes);
-  assert.ok(MyGame.Example.Monster.bufferHasIdentifier(bb));
-  var mon = MyGame.Example.Monster.getRootAsMonster(bb);
+  assert.ok(Monster.bufferHasIdentifier(bb));
+  var mon = Monster.getRootAsMonster(bb);
 
   var stat = mon.testempty();
   assert.strictEqual(stat != null, true);
   assert.strictEqual(stat.val() != null, true);
-  assert.strictEqual(stat.val().toFloat64(), 2541551405100253985);
+  assert.strictEqual(stat.val(), 2541551405100253985n);
 
   var mon2 = mon.enemy();
   assert.strictEqual(mon2 != null, true);
   stat = mon2.testempty();
   assert.strictEqual(stat != null, true);
   assert.strictEqual(stat.val() != null, true);
-  assert.strictEqual(stat.val().low, 0); // default value
-  assert.strictEqual(stat.val().high, 0);
+  assert.strictEqual(stat.val(), 0n); // default value
 }
 
 function testUnicode() {
@@ -285,19 +289,19 @@
 
   // Test reading
   function testReadingUnicode(bb) {
-    var monster = MyGame.Example.Monster.getRootAsMonster(bb);
+    var monster = Monster.getRootAsMonster(bb);
     assert.strictEqual(monster.name(), json.name);
-    assert.deepEqual(new Buffer(monster.name(flatbuffers.Encoding.UTF8_BYTES)), new Buffer(json.name));
+    assert.deepEqual(Buffer.from(monster.name(flatbuffers.Encoding.UTF8_BYTES)), Buffer.from(json.name));
     assert.strictEqual(monster.testarrayoftablesLength(), json.testarrayoftables.length);
     json.testarrayoftables.forEach(function(table, i) {
       var value = monster.testarrayoftables(i);
       assert.strictEqual(value.name(), table.name);
-      assert.deepEqual(new Buffer(value.name(flatbuffers.Encoding.UTF8_BYTES)), new Buffer(table.name));
+      assert.deepEqual(Buffer.from(value.name(flatbuffers.Encoding.UTF8_BYTES)), Buffer.from(table.name));
     });
     assert.strictEqual(monster.testarrayofstringLength(), json.testarrayofstring.length);
     json.testarrayofstring.forEach(function(string, i) {
       assert.strictEqual(monster.testarrayofstring(i), string);
-      assert.deepEqual(new Buffer(monster.testarrayofstring(i, flatbuffers.Encoding.UTF8_BYTES)), new Buffer(string));
+      assert.deepEqual(Buffer.from(monster.testarrayofstring(i, flatbuffers.Encoding.UTF8_BYTES)), Buffer.from(string));
     });
   }
   testReadingUnicode(new flatbuffers.ByteBuffer(new Uint8Array(correct)));
@@ -306,20 +310,20 @@
   var fbb = new flatbuffers.Builder();
   var name = fbb.createString(json.name);
   var testarrayoftablesOffsets = json.testarrayoftables.map(function(table) {
-    var name = fbb.createString(new Uint8Array(new Buffer(table.name)));
-    MyGame.Example.Monster.startMonster(fbb);
-    MyGame.Example.Monster.addName(fbb, name);
-    return MyGame.Example.Monster.endMonster(fbb);
+    var name = fbb.createString(new Uint8Array(Buffer.from(table.name)));
+    Monster.startMonster(fbb);
+    Monster.addName(fbb, name);
+    return Monster.endMonster(fbb);
   });
-  var testarrayoftablesOffset = MyGame.Example.Monster.createTestarrayoftablesVector(fbb,
+  var testarrayoftablesOffset = Monster.createTestarrayoftablesVector(fbb,
     testarrayoftablesOffsets);
-  var testarrayofstringOffset = MyGame.Example.Monster.createTestarrayofstringVector(fbb,
+  var testarrayofstringOffset = Monster.createTestarrayofstringVector(fbb,
     json.testarrayofstring.map(function(string) { return fbb.createString(string); }));
-  MyGame.Example.Monster.startMonster(fbb);
-  MyGame.Example.Monster.addTestarrayofstring(fbb, testarrayofstringOffset);
-  MyGame.Example.Monster.addTestarrayoftables(fbb, testarrayoftablesOffset);
-  MyGame.Example.Monster.addName(fbb, name);
-  MyGame.Example.Monster.finishSizePrefixedMonsterBuffer(fbb, MyGame.Example.Monster.endMonster(fbb));
+  Monster.startMonster(fbb);
+  Monster.addTestarrayofstring(fbb, testarrayofstringOffset);
+  Monster.addTestarrayoftables(fbb, testarrayoftablesOffset);
+  Monster.addName(fbb, name);
+  Monster.finishSizePrefixedMonsterBuffer(fbb, Monster.endMonster(fbb));
   var bb = new flatbuffers.ByteBuffer(fbb.asUint8Array())
   bb.setPosition(4);
   testReadingUnicode(bb);
@@ -366,8 +370,8 @@
   var ushort_val = 0xFEEE;
   var int_val    = 0x83333333 | 0;
   var uint_val   = 0xFDDDDDDD;
-  var long_val   = new flatbuffers.Long(0x44444444, 0x84444444);
-  var ulong_val  = new flatbuffers.Long(0xCCCCCCCC, 0xFCCCCCCC);
+  var long_val   = BigInt.asIntN(64, 0x8444444444444444n);
+  var ulong_val  = BigInt.asUintN(64, 0xFCCCCCCCCCCCCCCCn);
   var float_val  = new Float32Array([3.14159])[0];
   var double_val = 3.14159265359;
 
@@ -388,16 +392,16 @@
     for (var f = 0; f < fields_per_object; f++) {
       var choice = lcg_rand() % test_values_max;
       switch (choice) {
-        case 0:  builder.addFieldInt8(f, bool_val,   0); break;
-        case 1:  builder.addFieldInt8(f, char_val,   0); break;
-        case 2:  builder.addFieldInt8(f, uchar_val,  0); break;
-        case 3:  builder.addFieldInt16(f, short_val,  0); break;
+        case 0:  builder.addFieldInt8(f, bool_val, 0); break;
+        case 1:  builder.addFieldInt8(f, char_val, 0); break;
+        case 2:  builder.addFieldInt8(f, uchar_val, 0); break;
+        case 3:  builder.addFieldInt16(f, short_val, 0); break;
         case 4:  builder.addFieldInt16(f, ushort_val, 0); break;
-        case 5:  builder.addFieldInt32(f, int_val,    0); break;
-        case 6:  builder.addFieldInt32(f, uint_val,   0); break;
-        case 7:  builder.addFieldInt64(f, long_val,   flatbuffers.Long.ZERO); break;
-        case 8:  builder.addFieldInt64(f, ulong_val,  flatbuffers.Long.ZERO); break;
-        case 9:  builder.addFieldFloat32(f, float_val,  0); break;
+        case 5:  builder.addFieldInt32(f, int_val, 0); break;
+        case 6:  builder.addFieldInt32(f, uint_val, 0); break;
+        case 7:  builder.addFieldInt64(f, long_val, 0n); break;
+        case 8:  builder.addFieldInt64(f, ulong_val, 0n); break;
+        case 9:  builder.addFieldFloat32(f, float_val, 0); break;
         case 10: builder.addFieldFloat64(f, double_val, 0); break;
       }
     }
@@ -430,8 +434,8 @@
         case 4:  assert.strictEqual(view.getUint16(field_offset, true), ushort_val); break;
         case 5:  assert.strictEqual(view.getInt32(field_offset, true), int_val); break;
         case 6:  assert.strictEqual(view.getUint32(field_offset, true), uint_val); break;
-        case 7:  assert.strictEqual(view.getInt32(field_offset, true), long_val.low); assert.strictEqual(view.getInt32(field_offset + 4, true), long_val.high); break;
-        case 8:  assert.strictEqual(view.getInt32(field_offset, true), ulong_val.low); assert.strictEqual(view.getInt32(field_offset + 4, true), ulong_val.high); break;
+        case 7:  assert.strictEqual(view.getBigInt64(field_offset, true), long_val); break;
+        case 8:  assert.strictEqual(view.getBigUint64(field_offset, true), ulong_val); break;
         case 9:  assert.strictEqual(view.getFloat32(field_offset, true), float_val); break;
         case 10: assert.strictEqual(view.getFloat64(field_offset, true), double_val); break;
       }