hart-estate-widget 0.0.48 → 0.0.51

package/build/utils/csg/csg-worker.js

@@ -1,33 +1,23 @@
 "use strict";
 
-require("core-js/modules/es.promise.js");
-
-require("core-js/modules/web.dom-collections.iterator.js");
-
-require("core-js/modules/web.url.js");
-
-require("core-js/modules/web.url-search-params.js");
-
-require("core-js/modules/es.json.stringify.js");
-
 var _react = _interopRequireDefault(require("react"));
 
 var _csgLib = require("./csg-lib.js");
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-let gWorkersStarted = false;
-let gWorker;
-let gWorkerUrl;
-let taskId = 0;
-let tasks = {};
+var gWorkersStarted = false;
+var gWorker;
+var gWorkerUrl;
+var taskId = 0;
+var tasks = {};
 
-let spawnWorker = () => {
-  const worker = new Worker(gWorkerUrl);
+var spawnWorker = function spawnWorker() {
+  var worker = new Worker(gWorkerUrl);
 
   worker.onmessage = function (e) {
-    let rslt = JSON.parse(e.data);
-    let task = tasks[rslt.taskId];
+    var rslt = JSON.parse(e.data);
+    var task = tasks[rslt.taskId];
     delete tasks[rslt.taskId];
     task.resolve(_csgLib.CSG.fromJSON(rslt.result)); //console.log('Message received from worker');
 
@@ -35,23 +25,23 @@ let spawnWorker = () => {
   };
 
   return gWorker = {
-    worker,
+    worker: worker,
     busy: false
   };
 };
 
-let getWorker = () => {
+var getWorker = function getWorker() {
   if (!gWorkersStarted) {
     gWorkersStarted = true;
     return fetch('../csg-lib.js').then(function (response) {
       return response.text().then(function (text) {
         text = text.slice(0, text.lastIndexOf('export'));
-        const code = text + "\n                    self.onmessage=(message)=>{\n                    let task = JSON.parse(message.data)\n                    //console.log(\"Got task:\"+task.op+' '+task.taskId)\n                    postMessage(JSON.stringify({\n                        taskId:task.taskId,\n                        result : CSG.fromJSON(task.a)[task.op](CSG.fromJSON(task.b))\n                    }))\n                }\n                console.log('CSG worker started!')";
-        const blob = new Blob([code], {
+        var code = text + "\n                    self.onmessage=(message)=>{\n                    let task = JSON.parse(message.data)\n                    //console.log(\"Got task:\"+task.op+' '+task.taskId)\n                    postMessage(JSON.stringify({\n                        taskId:task.taskId,\n                        result : CSG.fromJSON(task.a)[task.op](CSG.fromJSON(task.b))\n                    }))\n                }\n                console.log('CSG worker started!')";
+        var blob = new Blob([code], {
           type: 'application/javascript'
         });
         gWorkerUrl = URL.createObjectURL(blob);
-      }).then(() => {
+      }).then(function () {
         return spawnWorker();
       });
     });
@@ -60,7 +50,7 @@ let getWorker = () => {
   if (gWorker && !gWorker.busy) {
     gWorker.busy = true;
     return {
-      then: fn => {
+      then: function then(fn) {
         return fn(gWorker);
       }
     };
@@ -73,17 +63,17 @@ let getWorker = () => {
   };
 };
 
-_csgLib.CSG.doAsync = (a, op, b) => {
-  return getWorker().then(worker => {
-    let task = {
-      a,
-      op,
-      b,
-      taskId
+_csgLib.CSG.doAsync = function (a, op, b) {
+  return getWorker().then(function (worker) {
+    var task = {
+      a: a,
+      op: op,
+      b: b,
+      taskId: taskId
     };
     tasks[taskId] = task;
     taskId++;
-    task.result = new Promise((resolve, reject) => {
+    task.result = new Promise(function (resolve, reject) {
       task.resolve = resolve; //console.log("posting to worker:")
 
       worker.busy = true;

package/build/utils/csg/three-csg.js

@@ -1,22 +1,12 @@
 "use strict";
 
-require("core-js/modules/web.dom-collections.iterator.js");
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
 
-require("core-js/modules/es.array-buffer.slice.js");
-
-require("core-js/modules/es.typed-array.float32-array.js");
-
-require("core-js/modules/es.typed-array.set.js");
-
-require("core-js/modules/es.typed-array.sort.js");
-
-require("core-js/modules/es.typed-array.to-locale-string.js");
-
 var _react = _interopRequireDefault(require("react"));
 
 var THREE = _interopRequireWildcard(require("three"));
@@ -27,67 +17,70 @@ require("./csg-worker.js");
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-let {
-  Geometry,
-  BufferGeometry,
-  Vector3,
-  Vector2
-} = THREE;
+var Geometry = THREE.Geometry,
+    BufferGeometry = THREE.BufferGeometry,
+    Vector3 = THREE.Vector3,
+    Vector2 = THREE.Vector2;
 
 _csgLib.CSG.fromGeometry = function (geom, objectIndex) {
-  let polys = [];
+  var polys = [];
 
   if (geom.isGeometry) {
-    let fs = geom.faces;
-    let vs = geom.vertices;
-    let fm = ['a', 'b', 'c'];
+    var fs = geom.faces;
+    var vs = geom.vertices;
+    var fm = ['a', 'b', 'c'];
 
-    for (let i = 0; i < fs.length; i++) {
-      let f = fs[i];
-      let vertices = [];
+    for (var i = 0; i < fs.length; i++) {
+      var f = fs[i];
+      var vertices = [];
 
-      for (let j = 0; j < 3; j++) vertices.push(new _csgLib.Vertex(vs[f[fm[j]]], f.vertexNormals[j], geom.faceVertexUvs[0][i][j]));
+      for (var j = 0; j < 3; j++) {
+        vertices.push(new _csgLib.Vertex(vs[f[fm[j]]], f.vertexNormals[j], geom.faceVertexUvs[0][i][j]));
+      }
 
       polys.push(new _csgLib.Polygon(vertices, objectIndex));
     }
   } else if (geom.isBufferGeometry) {
-    let vertices, normals, uvs;
-    let posattr = geom.attributes.position;
-    let normalattr = geom.attributes.normal;
-    let uvattr = geom.attributes.uv;
-    let colorattr = geom.attributes.color;
-    let index;
+    var _vertices, normals, uvs;
+
+    var posattr = geom.attributes.position;
+    var normalattr = geom.attributes.normal;
+    var uvattr = geom.attributes.uv;
+    var colorattr = geom.attributes.color;
+    var index;
     if (geom.index) index = geom.index.array;else {
       index = new Array(posattr.array.length / posattr.itemSize | 0);
 
-      for (let i = 0; i < index.length; i++) index[i] = i;
+      for (var _i = 0; _i < index.length; _i++) {
+        index[_i] = _i;
+      }
     }
-    let triCount = index.length / 3 | 0;
+    var triCount = index.length / 3 | 0;
     polys = new Array(triCount);
 
-    for (let i = 0, pli = 0, l = index.length; i < l; i += 3, pli++) {
-      let vertices = new Array(3);
-
-      for (let j = 0; j < 3; j++) {
-        let vi = index[i + j];
-        let vp = vi * 3;
-        let vt = vi * 2;
-        let x = posattr.array[vp];
-        let y = posattr.array[vp + 1];
-        let z = posattr.array[vp + 2];
-        let nx = normalattr.array[vp];
-        let ny = normalattr.array[vp + 1];
-        let nz = normalattr.array[vp + 2]; //let u = uvattr.array[vt]
+    for (var _i2 = 0, pli = 0, l = index.length; _i2 < l; _i2 += 3, pli++) {
+      var _vertices2 = new Array(3);
+
+      for (var _j = 0; _j < 3; _j++) {
+        var vi = index[_i2 + _j];
+        var vp = vi * 3;
+        var vt = vi * 2;
+        var x = posattr.array[vp];
+        var y = posattr.array[vp + 1];
+        var z = posattr.array[vp + 2];
+        var nx = normalattr.array[vp];
+        var ny = normalattr.array[vp + 1];
+        var nz = normalattr.array[vp + 2]; //let u = uvattr.array[vt]
         //let v = uvattr.array[vt + 1]
 
-        vertices[j] = new _csgLib.Vertex({
-          x,
-          y,
-          z
+        _vertices2[_j] = new _csgLib.Vertex({
+          x: x,
+          y: y,
+          z: z
         }, {
           x: nx,
           y: ny,
@@ -103,26 +96,26 @@ _csgLib.CSG.fromGeometry = function (geom, objectIndex) {
         });
       }
 
-      polys[pli] = new _csgLib.Polygon(vertices, objectIndex);
+      polys[pli] = new _csgLib.Polygon(_vertices2, objectIndex);
     }
   } else console.error("Unsupported CSG input type:" + geom.type);
 
   return _csgLib.CSG.fromPolygons(polys);
 };
 
-let ttvv0 = new THREE.Vector3();
-let tmpm3 = new THREE.Matrix3();
+var ttvv0 = new THREE.Vector3();
+var tmpm3 = new THREE.Matrix3();
 
 _csgLib.CSG.fromMesh = function (mesh, objectIndex) {
-  let csg = _csgLib.CSG.fromGeometry(mesh.geometry, objectIndex);
+  var csg = _csgLib.CSG.fromGeometry(mesh.geometry, objectIndex);
 
   tmpm3.getNormalMatrix(mesh.matrix);
 
-  for (let i = 0; i < csg.polygons.length; i++) {
-    let p = csg.polygons[i];
+  for (var i = 0; i < csg.polygons.length; i++) {
+    var p = csg.polygons[i];
 
-    for (let j = 0; j < p.vertices.length; j++) {
-      let v = p.vertices[j];
+    for (var j = 0; j < p.vertices.length; j++) {
+      var v = p.vertices[j];
       v.pos.copy(ttvv0.copy(v.pos).applyMatrix4(mesh.matrix));
       v.normal.copy(ttvv0.copy(v.normal).applyMatrix3(tmpm3));
     }
@@ -131,7 +124,7 @@ _csgLib.CSG.fromMesh = function (mesh, objectIndex) {
   return csg;
 };
 
-let nbuf3 = ct => {
+var nbuf3 = function nbuf3(ct) {
   return {
     top: 0,
     array: new Float32Array(ct),
@@ -143,7 +136,7 @@ let nbuf3 = ct => {
   };
 };
 
-let nbuf2 = ct => {
+var nbuf2 = function nbuf2(ct) {
   return {
     top: 0,
     array: new Float32Array(ct),
@@ -155,39 +148,41 @@ let nbuf2 = ct => {
 };
 
 _csgLib.CSG.toGeometry = function (csg) {
-  let buffered = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
-  let ps = csg.polygons;
-  let geom;
-  let g2;
+  var buffered = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  var ps = csg.polygons;
+  var geom;
+  var g2;
 
   if (!buffered) //Old geometry path...
     {
       geom = new Geometry();
-      let vs = geom.vertices;
-      let fvuv = geom.faceVertexUvs[0];
+      var vs = geom.vertices;
+      var fvuv = geom.faceVertexUvs[0];
 
-      for (let i = 0; i < ps.length; i++) {
-        let p = ps[i];
-        let pvs = p.vertices;
-        let v0 = vs.length;
-        let pvlen = pvs.length;
+      for (var i = 0; i < ps.length; i++) {
+        var p = ps[i];
+        var pvs = p.vertices;
+        var v0 = vs.length;
+        var pvlen = pvs.length;
 
-        for (let j = 0; j < pvlen; j++) vs.push(new THREE.Vector3().copy(pvs[j].pos));
+        for (var j = 0; j < pvlen; j++) {
+          vs.push(new THREE.Vector3().copy(pvs[j].pos));
+        }
 
-        for (let j = 3; j <= pvlen; j++) {
-          let fc = new THREE.Face3();
-          let fuv = [];
+        for (var _j2 = 3; _j2 <= pvlen; _j2++) {
+          var fc = new THREE.Face3();
+          var fuv = [];
           fvuv.push(fuv);
-          let fnml = fc.vertexNormals;
+          var fnml = fc.vertexNormals;
           fc.a = v0;
-          fc.b = v0 + j - 2;
-          fc.c = v0 + j - 1;
+          fc.b = v0 + _j2 - 2;
+          fc.c = v0 + _j2 - 1;
           fnml.push(new THREE.Vector3().copy(pvs[0].normal));
-          fnml.push(new THREE.Vector3().copy(pvs[j - 2].normal));
-          fnml.push(new THREE.Vector3().copy(pvs[j - 1].normal));
+          fnml.push(new THREE.Vector3().copy(pvs[_j2 - 2].normal));
+          fnml.push(new THREE.Vector3().copy(pvs[_j2 - 1].normal));
           fuv.push(new THREE.Vector3().copy(pvs[0].uv));
-          fuv.push(new THREE.Vector3().copy(pvs[j - 2].uv));
-          fuv.push(new THREE.Vector3().copy(pvs[j - 1].uv));
+          fuv.push(new THREE.Vector3().copy(pvs[_j2 - 2].uv));
+          fuv.push(new THREE.Vector3().copy(pvs[_j2 - 1].uv));
           fc.normal = new THREE.Vector3().copy(p.plane.normal);
           geom.faces.push(fc);
         }
@@ -197,18 +192,20 @@ _csgLib.CSG.toGeometry = function (csg) {
       geom.verticesNeedUpdate = geom.elementsNeedUpdate = geom.normalsNeedUpdate = true;
     } else {
     //BufferGeometry path
-    let triCount = 0;
-    ps.forEach(p => triCount += p.vertices.length - 2);
+    var triCount = 0;
+    ps.forEach(function (p) {
+      return triCount += p.vertices.length - 2;
+    });
     geom = new THREE.BufferGeometry();
-    let vertices = nbuf3(triCount * 3 * 3);
-    let normals = nbuf3(triCount * 3 * 3);
-    let uvs; // = nbuf2(triCount * 2 * 3)
+    var vertices = nbuf3(triCount * 3 * 3);
+    var normals = nbuf3(triCount * 3 * 3);
+    var uvs; // = nbuf2(triCount * 2 * 3)
 
-    let colors;
-    let grps = [];
-    ps.forEach(p => {
-      let pvs = p.vertices;
-      let pvlen = pvs.length;
+    var colors;
+    var grps = [];
+    ps.forEach(function (p) {
+      var pvs = p.vertices;
+      var pvlen = pvs.length;
 
       if (p.shared !== undefined) {
         if (!grps[p.shared]) grps[p.shared] = [];
@@ -224,16 +221,16 @@ _csgLib.CSG.toGeometry = function (csg) {
         }
       }
 
-      for (let j = 3; j <= pvlen; j++) {
+      for (var _j3 = 3; _j3 <= pvlen; _j3++) {
         p.shared !== undefined && grps[p.shared].push(vertices.top / 3, vertices.top / 3 + 1, vertices.top / 3 + 2);
         vertices.write(pvs[0].pos);
-        vertices.write(pvs[j - 2].pos);
-        vertices.write(pvs[j - 1].pos);
+        vertices.write(pvs[_j3 - 2].pos);
+        vertices.write(pvs[_j3 - 1].pos);
         normals.write(pvs[0].normal);
-        normals.write(pvs[j - 2].normal);
-        normals.write(pvs[j - 1].normal);
-        uvs && pvs[0].uv && (uvs.write(pvs[0].uv) || uvs.write(pvs[j - 2].uv) || uvs.write(pvs[j - 1].uv));
-        colors && (colors.write(pvs[0].color) || colors.write(pvs[j - 2].color) || colors.write(pvs[j - 1].color));
+        normals.write(pvs[_j3 - 2].normal);
+        normals.write(pvs[_j3 - 1].normal);
+        uvs && pvs[0].uv && (uvs.write(pvs[0].uv) || uvs.write(pvs[_j3 - 2].uv) || uvs.write(pvs[_j3 - 1].uv));
+        colors && (colors.write(pvs[0].color) || colors.write(pvs[_j3 - 2].color) || colors.write(pvs[_j3 - 1].color));
       }
     });
     geom.setAttribute('position', new THREE.BufferAttribute(vertices.array, 3));
@@ -242,10 +239,10 @@ _csgLib.CSG.toGeometry = function (csg) {
     colors && geom.setAttribute('color', new THREE.BufferAttribute(colors.array, 3));
 
     if (grps.length) {
-      let index = [];
-      let gbase = 0;
+      var index = [];
+      var gbase = 0;
 
-      for (let gi = 0; gi < grps.length; gi++) {
+      for (var gi = 0; gi < grps.length; gi++) {
         geom.addGroup(gbase, grps[gi].length, gi);
         gbase += grps[gi].length;
         index = index.concat(grps[gi]);
@@ -261,13 +258,13 @@ _csgLib.CSG.toGeometry = function (csg) {
 };
 
 _csgLib.CSG.toMesh = function (csg, toMatrix, toMaterial) {
-  let geom = _csgLib.CSG.toGeometry(csg);
+  var geom = _csgLib.CSG.toGeometry(csg);
 
-  let inv = new THREE.Matrix4().copy(toMatrix).invert();
+  var inv = new THREE.Matrix4().copy(toMatrix).invert();
   geom.applyMatrix4(inv);
   geom.computeBoundingSphere();
   geom.computeBoundingBox();
-  let m = new THREE.Mesh(geom, toMaterial);
+  var m = new THREE.Mesh(geom, toMaterial);
   m.matrix.copy(toMatrix);
   m.matrix.decompose(m.position, m.quaternion, m.scale);
   m.rotation.setFromQuaternion(m.quaternion);

package/build/utils/modelHelpers.js

@@ -1,6 +1,6 @@
 "use strict";
 
-require("core-js/modules/web.dom-collections.iterator.js");
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
 
 Object.defineProperty(exports, "__esModule", {
   value: true
@@ -21,11 +21,11 @@ var _floorBathroom = _interopRequireDefault(require("../assets/img/floor-bathroo
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 
-function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
 function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-const FloorParams = {
+var FloorParams = {
   'default': {
     texture: _floorDark.default,
     roughnessMap: null,
@@ -48,8 +48,8 @@ const FloorParams = {
   }
 };
 
-const getKeyEvents = controls => {
-  const KEYCODE = {
+var getKeyEvents = function getKeyEvents(controls) {
+  var KEYCODE = {
     W: 87,
     A: 65,
     S: 83,
@@ -59,54 +59,60 @@ const getKeyEvents = controls => {
     ARROW_RIGHT: 39,
     ARROW_DOWN: 40
   };
-  const wKey = new holdEvent.KeyboardKeyHold(KEYCODE.W, 100);
-  const upKey = new holdEvent.KeyboardKeyHold(KEYCODE.ARROW_UP, 100);
-  const upArr = [wKey, upKey];
-  const aKey = new holdEvent.KeyboardKeyHold(KEYCODE.A, 100);
-  const leftKey = new holdEvent.KeyboardKeyHold(KEYCODE.ARROW_LEFT, 100);
-  const leftArr = [aKey, leftKey];
-  const sKey = new holdEvent.KeyboardKeyHold(KEYCODE.S, 100);
-  const downKey = new holdEvent.KeyboardKeyHold(KEYCODE.ARROW_DOWN, 100);
-  const downArr = [sKey, downKey];
-  const dKey = new holdEvent.KeyboardKeyHold(KEYCODE.D, 100);
-  const rightKey = new holdEvent.KeyboardKeyHold(KEYCODE.ARROW_RIGHT, 100);
-  const rightArr = [dKey, rightKey];
-  const keyEvents = [{
+  var wKey = new holdEvent.KeyboardKeyHold(KEYCODE.W, 100);
+  var upKey = new holdEvent.KeyboardKeyHold(KEYCODE.ARROW_UP, 100);
+  var upArr = [wKey, upKey];
+  var aKey = new holdEvent.KeyboardKeyHold(KEYCODE.A, 100);
+  var leftKey = new holdEvent.KeyboardKeyHold(KEYCODE.ARROW_LEFT, 100);
+  var leftArr = [aKey, leftKey];
+  var sKey = new holdEvent.KeyboardKeyHold(KEYCODE.S, 100);
+  var downKey = new holdEvent.KeyboardKeyHold(KEYCODE.ARROW_DOWN, 100);
+  var downArr = [sKey, downKey];
+  var dKey = new holdEvent.KeyboardKeyHold(KEYCODE.D, 100);
+  var rightKey = new holdEvent.KeyboardKeyHold(KEYCODE.ARROW_RIGHT, 100);
+  var rightArr = [dKey, rightKey];
+  var keyEvents = [{
     keys: upArr,
-    callback: () => controls.forward(1, true)
+    callback: function callback() {
+      return controls.forward(1, true);
+    }
   }, {
     keys: leftArr,
-    callback: () => controls.truck(-1, 0, true)
+    callback: function callback() {
+      return controls.truck(-1, 0, true);
+    }
   }, {
     keys: downArr,
-    callback: () => controls.forward(-1, true)
+    callback: function callback() {
+      return controls.forward(-1, true);
+    }
   }, {
     keys: rightArr,
-    callback: () => controls.truck(1, 0, true)
+    callback: function callback() {
+      return controls.truck(1, 0, true);
+    }
   }];
   return keyEvents;
 };
 
 exports.getKeyEvents = getKeyEvents;
 
-const getFloorParams = type => {
-  const params = FloorParams[type];
+var getFloorParams = function getFloorParams(type) {
+  var params = FloorParams[type];
   if (!params) return FloorParams['default'];
   return params;
 };
 
 exports.getFloorParams = getFloorParams;
 
-const getMinMaxCoordinates = walls => {
-  let maxX = 0;
-  let minX = Infinity;
-  let maxY = 0;
-  let minY = Infinity;
-  walls.forEach(_ref => {
-    let {
-      start,
-      end
-    } = _ref;
+var getMinMaxCoordinates = function getMinMaxCoordinates(walls) {
+  var maxX = 0;
+  var minX = Infinity;
+  var maxY = 0;
+  var minY = Infinity;
+  walls.forEach(function (_ref) {
+    var start = _ref.start,
+        end = _ref.end;
     // CALCULATE MAX COORDS
     if (start.x > maxX) maxX = start.x;
     if (start.x > maxX) maxX = start.x;
@@ -119,17 +125,17 @@ const getMinMaxCoordinates = walls => {
     if (end.y < minY) minY = end.y;
   });
   return {
-    maxX,
-    minX,
-    maxY,
-    minY
+    maxX: maxX,
+    minX: minX,
+    maxY: maxY,
+    minY: minY
   };
 };
 
 exports.getMinMaxCoordinates = getMinMaxCoordinates;
 
-const getDirectionsFromDegrees = deg => {
-  let directions = [];
+var getDirectionsFromDegrees = function getDirectionsFromDegrees(deg) {
+  var directions = [];
 
   if (deg > 80 && deg < 100) {
     directions = ['forward'];