diff --git a/index.html b/index.html
index 0033eef..e2f3375 100644
--- a/index.html
+++ b/index.html
@@ -183,7 +183,6 @@ <h4 class="modal-title" id="chooseBlocksLabel">Choose Blocks</h4>
   <script src="resources/js/tileKeys.js"></script>
   <script src="resources/js/itemKeys.js"></script>
   <script src="resources/js/wallKeys.js"></script>
-  <script src="resources/js/MapHelper.js"></script>
   <script src="resources/js/main.js"></script>
   <script async src="https://www.googletagmanager.com/gtag/js?id=G-P6BJH8276R"></script>
   <script>
diff --git a/resources/js/DataStream.js b/resources/js/DataStream.js
deleted file mode 100644
index 3463492..0000000
--- a/resources/js/DataStream.js
+++ /dev/null
@@ -1,1532 +0,0 @@
-/**
-  DataStream reads scalars, arrays and structs of data from an ArrayBuffer.
-  It's like a file-like DataView on steroids.
-
-  @param {ArrayBuffer} arrayBuffer ArrayBuffer to read from.
-  @param {?Number} byteOffset Offset from arrayBuffer beginning for the DataStream.
-  @param {?Boolean} endianness DataStream.BIG_ENDIAN or DataStream.LITTLE_ENDIAN (the default).
-  */
-DataStream = function(arrayBuffer, byteOffset, endianness) {
-  this._byteOffset = byteOffset || 0;
-  if (arrayBuffer instanceof ArrayBuffer) {
-    this.buffer = arrayBuffer;
-  } else if (typeof arrayBuffer == "object") {
-    this.dataView = arrayBuffer;
-    if (byteOffset) {
-      this._byteOffset += byteOffset;
-    }
-  } else {
-    this.buffer = new ArrayBuffer(arrayBuffer || 1);
-  }
-  this.position = 0;
-  this.endianness = endianness == null ? DataStream.LITTLE_ENDIAN : endianness;
-};
-DataStream.prototype = {};
-
-/* Fix for Opera 12 not defining BYTES_PER_ELEMENT in typed array prototypes. */
-if (Uint8Array.prototype.BYTES_PER_ELEMENT === undefined) {
-    Uint8Array.prototype.BYTES_PER_ELEMENT = Uint8Array.BYTES_PER_ELEMENT; 
-    Int8Array.prototype.BYTES_PER_ELEMENT = Int8Array.BYTES_PER_ELEMENT; 
-    Uint8ClampedArray.prototype.BYTES_PER_ELEMENT = Uint8ClampedArray.BYTES_PER_ELEMENT; 
-    Uint16Array.prototype.BYTES_PER_ELEMENT = Uint16Array.BYTES_PER_ELEMENT; 
-    Int16Array.prototype.BYTES_PER_ELEMENT = Int16Array.BYTES_PER_ELEMENT; 
-    Uint32Array.prototype.BYTES_PER_ELEMENT = Uint32Array.BYTES_PER_ELEMENT; 
-    Int32Array.prototype.BYTES_PER_ELEMENT = Int32Array.BYTES_PER_ELEMENT; 
-    Float64Array.prototype.BYTES_PER_ELEMENT = Float64Array.BYTES_PER_ELEMENT; 
-}
-
-/**
-  Saves the DataStream contents to the given filename.
-  Uses Chrome's anchor download property to initiate download.
-
-  @param {string} filename Filename to save as.
-  @return {null}
-  */
-DataStream.prototype.save = function(filename) {
-  var blob = new Blob(this.buffer);
-  var URL = (window.webkitURL || window.URL);
-  if (URL && URL.createObjectURL) {
-      var url = URL.createObjectURL(blob);
-      var a = document.createElement('a');
-      a.setAttribute('href', url);
-      a.setAttribute('download', filename);
-      a.click();
-      URL.revokeObjectURL(url);
-  } else {
-      throw("DataStream.save: Can't create object URL.");
-  }
-};
-
-/**
-  Big-endian const to use as default endianness.
-  @type {boolean}
-  */
-DataStream.BIG_ENDIAN = false;
-
-/**
-  Little-endian const to use as default endianness.
-  @type {boolean}
-  */
-DataStream.LITTLE_ENDIAN = true;
-
-/**
-  Whether to extend DataStream buffer when trying to write beyond its size.
-  If set, the buffer is reallocated to twice its current size until the
-  requested write fits the buffer.
-  @type {boolean}
-  */
-DataStream.prototype._dynamicSize = true;
-Object.defineProperty(DataStream.prototype, 'dynamicSize',
-  { get: function() {
-      return this._dynamicSize;
-    },
-    set: function(v) {
-      if (!v) {
-        this._trimAlloc();
-      }
-      this._dynamicSize = v;
-    } });
-
-/**
-  Virtual byte length of the DataStream backing buffer.
-  Updated to be max of original buffer size and last written size.
-  If dynamicSize is false is set to buffer size.
-  @type {number}
-  */
-DataStream.prototype._byteLength = 0;
-
-/**
-  Returns the byte length of the DataStream object.
-  @type {number}
-  */
-Object.defineProperty(DataStream.prototype, 'byteLength',
-  { get: function() {
-    return this._byteLength - this._byteOffset;
-  }});
-
-/**
-  Set/get the backing ArrayBuffer of the DataStream object.
-  The setter updates the DataView to point to the new buffer.
-  @type {Object}
-  */
-Object.defineProperty(DataStream.prototype, 'buffer',
-  { get: function() {
-      this._trimAlloc();
-      return this._buffer;
-    },
-    set: function(v) {
-      this._buffer = v;
-      this._dataView = new DataView(this._buffer, this._byteOffset);
-      this._byteLength = this._buffer.byteLength;
-    } });
-
-/**
-  Set/get the byteOffset of the DataStream object.
-  The setter updates the DataView to point to the new byteOffset.
-  @type {number}
-  */
-Object.defineProperty(DataStream.prototype, 'byteOffset',
-  { get: function() {
-      return this._byteOffset;
-    },
-    set: function(v) {
-      this._byteOffset = v;
-      this._dataView = new DataView(this._buffer, this._byteOffset);
-      this._byteLength = this._buffer.byteLength;
-    } });
-
-/**
-  Set/get the backing DataView of the DataStream object.
-  The setter updates the buffer and byteOffset to point to the DataView values.
-  @type {Object}
-  */
-Object.defineProperty(DataStream.prototype, 'dataView',
-  { get: function() {
-      return this._dataView;
-    },
-    set: function(v) {
-      this._byteOffset = v.byteOffset;
-      this._buffer = v.buffer;
-      this._dataView = new DataView(this._buffer, this._byteOffset);
-      this._byteLength = this._byteOffset + v.byteLength;
-    } });
-
-/**
-  Internal function to resize the DataStream buffer when required.
-  @param {number} extra Number of bytes to add to the buffer allocation.
-  @return {null}
-  */
-DataStream.prototype._realloc = function(extra) {
-  if (!this._dynamicSize) {
-    return;
-  }
-  var req = this._byteOffset + this.position + extra;
-  var blen = this._buffer.byteLength;
-  if (req <= blen) {
-    if (req > this._byteLength) {
-      this._byteLength = req;
-    }
-    return;
-  }
-  if (blen < 1) {
-    blen = 1;
-  }
-  while (req > blen) {
-    blen *= 2;
-  }
-  var buf = new ArrayBuffer(blen);
-  var src = new Uint8Array(this._buffer);
-  var dst = new Uint8Array(buf, 0, src.length);
-  dst.set(src);
-  this.buffer = buf;
-  this._byteLength = req;
-};
-
-/**
-  Internal function to trim the DataStream buffer when required.
-  Used for stripping out the extra bytes from the backing buffer when
-  the virtual byteLength is smaller than the buffer byteLength (happens after
-  growing the buffer with writes and not filling the extra space completely).
-
-  @return {null}
-  */
-DataStream.prototype._trimAlloc = function() {
-  if (this._byteLength == this._buffer.byteLength) {
-    return;
-  }
-  var buf = new ArrayBuffer(this._byteLength);
-  var dst = new Uint8Array(buf);
-  var src = new Uint8Array(this._buffer, 0, dst.length);
-  dst.set(src);
-  this.buffer = buf;
-};
-
-/**
-  Sets the DataStream read/write position to given position.
-  Clamps between 0 and DataStream length.
-
-  @param {number} pos Position to seek to.
-  @return {null}
-  */
-DataStream.prototype.seek = function(pos) {
-  var npos = Math.max(0, Math.min(this.byteLength, pos));
-  this.position = (isNaN(npos) || !isFinite(npos)) ? 0 : npos;
-};
-
-/**
-  Returns true if the DataStream seek pointer is at the end of buffer and
-  there's no more data to read.
-
-  @return {boolean} True if the seek pointer is at the end of the buffer.
-  */
-DataStream.prototype.isEof = function() {
-  return (this.position >= this.byteLength);
-};
-
-/**
-  Maps an Int32Array into the DataStream buffer, swizzling it to native
-  endianness in-place. The current offset from the start of the buffer needs to
-  be a multiple of element size, just like with typed array views.
-
-  Nice for quickly reading in data. Warning: potentially modifies the buffer
-  contents.
-
-  @param {number} length Number of elements to map.
-  @param {?boolean} e Endianness of the data to read.
-  @return {Object} Int32Array to the DataStream backing buffer.
-  */
-DataStream.prototype.mapInt32Array = function(length, e) {
-  this._realloc(length * 4);
-  var arr = new Int32Array(this._buffer, this.byteOffset+this.position, length);
-  DataStream.arrayToNative(arr, e == null ? this.endianness : e);
-  this.position += length * 4;
-  return arr;
-};
-
-/**
-  Maps an Int16Array into the DataStream buffer, swizzling it to native
-  endianness in-place. The current offset from the start of the buffer needs to
-  be a multiple of element size, just like with typed array views.
-
-  Nice for quickly reading in data. Warning: potentially modifies the buffer
-  contents.
-
-  @param {number} length Number of elements to map.
-  @param {?boolean} e Endianness of the data to read.
-  @return {Object} Int16Array to the DataStream backing buffer.
-  */
-DataStream.prototype.mapInt16Array = function(length, e) {
-  this._realloc(length * 2);
-  var arr = new Int16Array(this._buffer, this.byteOffset+this.position, length);
-  DataStream.arrayToNative(arr, e == null ? this.endianness : e);
-  this.position += length * 2;
-  return arr;
-};
-
-/**
-  Maps an Int8Array into the DataStream buffer.
-
-  Nice for quickly reading in data.
-
-  @param {number} length Number of elements to map.
-  @param {?boolean} e Endianness of the data to read.
-  @return {Object} Int8Array to the DataStream backing buffer.
-  */
-DataStream.prototype.mapInt8Array = function(length) {
-  this._realloc(length * 1);
-  var arr = new Int8Array(this._buffer, this.byteOffset+this.position, length);
-  this.position += length * 1;
-  return arr;
-};
-
-/**
-  Maps a Uint32Array into the DataStream buffer, swizzling it to native
-  endianness in-place. The current offset from the start of the buffer needs to
-  be a multiple of element size, just like with typed array views.
-
-  Nice for quickly reading in data. Warning: potentially modifies the buffer
-  contents.
-
-  @param {number} length Number of elements to map.
-  @param {?boolean} e Endianness of the data to read.
-  @return {Object} Uint32Array to the DataStream backing buffer.
-  */
-DataStream.prototype.mapUint32Array = function(length, e) {
-  this._realloc(length * 4);
-  var arr = new Uint32Array(this._buffer, this.byteOffset+this.position, length);
-  DataStream.arrayToNative(arr, e == null ? this.endianness : e);
-  this.position += length * 4;
-  return arr;
-};
-
-/**
-  Maps a Uint16Array into the DataStream buffer, swizzling it to native
-  endianness in-place. The current offset from the start of the buffer needs to
-  be a multiple of element size, just like with typed array views.
-
-  Nice for quickly reading in data. Warning: potentially modifies the buffer
-  contents.
-
-  @param {number} length Number of elements to map.
-  @param {?boolean} e Endianness of the data to read.
-  @return {Object} Uint16Array to the DataStream backing buffer.
-  */
-DataStream.prototype.mapUint16Array = function(length, e) {
-  this._realloc(length * 2);
-  var arr = new Uint16Array(this._buffer, this.byteOffset+this.position, length);
-  DataStream.arrayToNative(arr, e == null ? this.endianness : e);
-  this.position += length * 2;
-  return arr;
-};
-
-/**
-  Maps a Uint8Array into the DataStream buffer.
-
-  Nice for quickly reading in data.
-
-  @param {number} length Number of elements to map.
-  @param {?boolean} e Endianness of the data to read.
-  @return {Object} Uint8Array to the DataStream backing buffer.
-  */
-DataStream.prototype.mapUint8Array = function(length) {
-  this._realloc(length * 1);
-  var arr = new Uint8Array(this._buffer, this.byteOffset+this.position, length);
-  this.position += length * 1;
-  return arr;
-};
-
-/**
-  Maps a Float64Array into the DataStream buffer, swizzling it to native
-  endianness in-place. The current offset from the start of the buffer needs to
-  be a multiple of element size, just like with typed array views.
-
-  Nice for quickly reading in data. Warning: potentially modifies the buffer
-  contents.
-
-  @param {number} length Number of elements to map.
-  @param {?boolean} e Endianness of the data to read.
-  @return {Object} Float64Array to the DataStream backing buffer.
-  */
-DataStream.prototype.mapFloat64Array = function(length, e) {
-  this._realloc(length * 8);
-  var arr = new Float64Array(this._buffer, this.byteOffset+this.position, length);
-  DataStream.arrayToNative(arr, e == null ? this.endianness : e);
-  this.position += length * 8;
-  return arr;
-};
-
-/**
-  Maps a Float32Array into the DataStream buffer, swizzling it to native
-  endianness in-place. The current offset from the start of the buffer needs to
-  be a multiple of element size, just like with typed array views.
-
-  Nice for quickly reading in data. Warning: potentially modifies the buffer
-  contents.
-
-  @param {number} length Number of elements to map.
-  @param {?boolean} e Endianness of the data to read.
-  @return {Object} Float32Array to the DataStream backing buffer.
-  */
-DataStream.prototype.mapFloat32Array = function(length, e) {
-  this._realloc(length * 4);
-  var arr = new Float32Array(this._buffer, this.byteOffset+this.position, length);
-  DataStream.arrayToNative(arr, e == null ? this.endianness : e);
-  this.position += length * 4;
-  return arr;
-};
-
-/**
-  Reads an Int32Array of desired length and endianness from the DataStream.
-
-  @param {number} length Number of elements to map.
-  @param {?boolean} e Endianness of the data to read.
-  @return {Object} The read Int32Array.
- */
-DataStream.prototype.readInt32Array = function(length, e) {
-  length = length == null ? (this.byteLength-this.position / 4) : length;
-  var arr = new Int32Array(length);
-  DataStream.memcpy(arr.buffer, 0,
-                    this.buffer, this.byteOffset+this.position,
-                    length*arr.BYTES_PER_ELEMENT);
-  DataStream.arrayToNative(arr, e == null ? this.endianness : e);
-  this.position += arr.byteLength;
-  return arr;
-};
-
-/**
-  Reads an Int16Array of desired length and endianness from the DataStream.
-
-  @param {number} length Number of elements to map.
-  @param {?boolean} e Endianness of the data to read.
-  @return {Object} The read Int16Array.
- */
-DataStream.prototype.readInt16Array = function(length, e) {
-  length = length == null ? (this.byteLength-this.position / 2) : length;
-  var arr = new Int16Array(length);
-  DataStream.memcpy(arr.buffer, 0,
-                    this.buffer, this.byteOffset+this.position,
-                    length*arr.BYTES_PER_ELEMENT);
-  DataStream.arrayToNative(arr, e == null ? this.endianness : e);
-  this.position += arr.byteLength;
-  return arr;
-};
-
-/**
-  Reads an Int8Array of desired length from the DataStream.
-
-  @param {number} length Number of elements to map.
-  @param {?boolean} e Endianness of the data to read.
-  @return {Object} The read Int8Array.
- */
-DataStream.prototype.readInt8Array = function(length) {
-  length = length == null ? (this.byteLength-this.position) : length;
-  var arr = new Int8Array(length);
-  DataStream.memcpy(arr.buffer, 0,
-                    this.buffer, this.byteOffset+this.position,
-                    length*arr.BYTES_PER_ELEMENT);
-  this.position += arr.byteLength;
-  return arr;
-};
-
-/**
-  Reads a Uint32Array of desired length and endianness from the DataStream.
-
-  @param {number} length Number of elements to map.
-  @param {?boolean} e Endianness of the data to read.
-  @return {Object} The read Uint32Array.
- */
-DataStream.prototype.readUint32Array = function(length, e) {
-  length = length == null ? (this.byteLength-this.position / 4) : length;
-  var arr = new Uint32Array(length);
-  DataStream.memcpy(arr.buffer, 0,
-                    this.buffer, this.byteOffset+this.position,
-                    length*arr.BYTES_PER_ELEMENT);
-  DataStream.arrayToNative(arr, e == null ? this.endianness : e);
-  this.position += arr.byteLength;
-  return arr;
-};
-
-/**
-  Reads a Uint16Array of desired length and endianness from the DataStream.
-
-  @param {number} length Number of elements to map.
-  @param {?boolean} e Endianness of the data to read.
-  @return {Object} The read Uint16Array.
- */
-DataStream.prototype.readUint16Array = function(length, e) {
-  length = length == null ? (this.byteLength-this.position / 2) : length;
-  var arr = new Uint16Array(length);
-  DataStream.memcpy(arr.buffer, 0,
-                    this.buffer, this.byteOffset+this.position,
-                    length*arr.BYTES_PER_ELEMENT);
-  DataStream.arrayToNative(arr, e == null ? this.endianness : e);
-  this.position += arr.byteLength;
-  return arr;
-};
-
-/**
-  Reads a Uint8Array of desired length from the DataStream.
-
-  @param {number} length Number of elements to map.
-  @param {?boolean} e Endianness of the data to read.
-  @return {Object} The read Uint8Array.
- */
-DataStream.prototype.readUint8Array = function(length) {
-  length = length == null ? (this.byteLength-this.position) : length;
-  var arr = new Uint8Array(length);
-  DataStream.memcpy(arr.buffer, 0,
-                    this.buffer, this.byteOffset+this.position,
-                    length*arr.BYTES_PER_ELEMENT);
-  this.position += arr.byteLength;
-  return arr;
-};
-
-/**
-  Reads a Float64Array of desired length and endianness from the DataStream.
-
-  @param {number} length Number of elements to map.
-  @param {?boolean} e Endianness of the data to read.
-  @return {Object} The read Float64Array.
- */
-DataStream.prototype.readFloat64Array = function(length, e) {
-  length = length == null ? (this.byteLength-this.position / 8) : length;
-  var arr = new Float64Array(length);
-  DataStream.memcpy(arr.buffer, 0,
-                    this.buffer, this.byteOffset+this.position,
-                    length*arr.BYTES_PER_ELEMENT);
-  DataStream.arrayToNative(arr, e == null ? this.endianness : e);
-  this.position += arr.byteLength;
-  return arr;
-};
-
-/**
-  Reads a Float32Array of desired length and endianness from the DataStream.
-
-  @param {number} length Number of elements to map.
-  @param {?boolean} e Endianness of the data to read.
-  @return {Object} The read Float32Array.
- */
-DataStream.prototype.readFloat32Array = function(length, e) {
-  length = length == null ? (this.byteLength-this.position / 4) : length;
-  var arr = new Float32Array(length);
-  DataStream.memcpy(arr.buffer, 0,
-                    this.buffer, this.byteOffset+this.position,
-                    length*arr.BYTES_PER_ELEMENT);
-  DataStream.arrayToNative(arr, e == null ? this.endianness : e);
-  this.position += arr.byteLength;
-  return arr;
-};
-
-/**
-  Writes an Int32Array of specified endianness to the DataStream.
-
-  @param {Object} arr The array to write.
-  @param {?boolean} e Endianness of the data to write.
- */
-DataStream.prototype.writeInt32Array = function(arr, e) {
-  this._realloc(arr.length * 4);
-  if (arr instanceof Int32Array &&
-      this.byteOffset+this.position % arr.BYTES_PER_ELEMENT == 0) {
-    DataStream.memcpy(this._buffer, this.byteOffset+this.position,
-                      arr.buffer, 0,
-                      arr.byteLength);
-    this.mapInt32Array(arr.length, e);
-  } else {
-    for (var i=0; i<arr.length; i++) {
-      this.writeInt32(arr[i], e);
-    }
-  }
-};
-
-/**
-  Writes an Int16Array of specified endianness to the DataStream.
-
-  @param {Object} arr The array to write.
-  @param {?boolean} e Endianness of the data to write.
- */
-DataStream.prototype.writeInt16Array = function(arr, e) {
-  this._realloc(arr.length * 2);
-  if (arr instanceof Int16Array &&
-      this.byteOffset+this.position % arr.BYTES_PER_ELEMENT == 0) {
-    DataStream.memcpy(this._buffer, this.byteOffset+this.position,
-                      arr.buffer, 0,
-                      arr.byteLength);
-    this.mapInt16Array(arr.length, e);
-  } else {
-    for (var i=0; i<arr.length; i++) {
-      this.writeInt16(arr[i], e);
-    }
-  }
-};
-
-/**
-  Writes an Int8Array to the DataStream.
-
-  @param {Object} arr The array to write.
- */
-DataStream.prototype.writeInt8Array = function(arr) {
-  this._realloc(arr.length * 1);
-  if (arr instanceof Int8Array &&
-      this.byteOffset+this.position % arr.BYTES_PER_ELEMENT == 0) {
-    DataStream.memcpy(this._buffer, this.byteOffset+this.position,
-                      arr.buffer, 0,
-                      arr.byteLength);
-    this.mapInt8Array(arr.length);
-  } else {
-    for (var i=0; i<arr.length; i++) {
-      this.writeInt8(arr[i]);
-    }
-  }
-};
-
-/**
-  Writes a Uint32Array of specified endianness to the DataStream.
-
-  @param {Object} arr The array to write.
-  @param {?boolean} e Endianness of the data to write.
- */
-DataStream.prototype.writeUint32Array = function(arr, e) {
-  this._realloc(arr.length * 4);
-  if (arr instanceof Uint32Array &&
-      this.byteOffset+this.position % arr.BYTES_PER_ELEMENT == 0) {
-    DataStream.memcpy(this._buffer, this.byteOffset+this.position,
-                      arr.buffer, 0,
-                      arr.byteLength);
-    this.mapUint32Array(arr.length, e);
-  } else {
-    for (var i=0; i<arr.length; i++) {
-      this.writeUint32(arr[i], e);
-    }
-  }
-};
-
-/**
-  Writes a Uint16Array of specified endianness to the DataStream.
-
-  @param {Object} arr The array to write.
-  @param {?boolean} e Endianness of the data to write.
- */
-DataStream.prototype.writeUint16Array = function(arr, e) {
-  this._realloc(arr.length * 2);
-  if (arr instanceof Uint16Array &&
-      this.byteOffset+this.position % arr.BYTES_PER_ELEMENT == 0) {
-    DataStream.memcpy(this._buffer, this.byteOffset+this.position,
-                      arr.buffer, 0,
-                      arr.byteLength);
-    this.mapUint16Array(arr.length, e);
-  } else {
-    for (var i=0; i<arr.length; i++) {
-      this.writeUint16(arr[i], e);
-    }
-  }
-};
-
-/**
-  Writes a Uint8Array to the DataStream.
-
-  @param {Object} arr The array to write.
- */
-DataStream.prototype.writeUint8Array = function(arr) {
-  this._realloc(arr.length * 1);
-  if (arr instanceof Uint8Array &&
-      this.byteOffset+this.position % arr.BYTES_PER_ELEMENT == 0) {
-    DataStream.memcpy(this._buffer, this.byteOffset+this.position,
-                      arr.buffer, 0,
-                      arr.byteLength);
-    this.mapUint8Array(arr.length);
-  } else {
-    for (var i=0; i<arr.length; i++) {
-      this.writeUint8(arr[i]);
-    }
-  }
-};
-
-/**
-  Writes a Float64Array of specified endianness to the DataStream.
-
-  @param {Object} arr The array to write.
-  @param {?boolean} e Endianness of the data to write.
- */
-DataStream.prototype.writeFloat64Array = function(arr, e) {
-  this._realloc(arr.length * 8);
-  if (arr instanceof Float64Array &&
-      this.byteOffset+this.position % arr.BYTES_PER_ELEMENT == 0) {
-    DataStream.memcpy(this._buffer, this.byteOffset+this.position,
-                      arr.buffer, 0,
-                      arr.byteLength);
-    this.mapFloat64Array(arr.length, e);
-  } else {
-    for (var i=0; i<arr.length; i++) {
-      this.writeFloat64(arr[i], e);
-    }
-  }
-};
-
-/**
-  Writes a Float32Array of specified endianness to the DataStream.
-
-  @param {Object} arr The array to write.
-  @param {?boolean} e Endianness of the data to write.
- */
-DataStream.prototype.writeFloat32Array = function(arr, e) {
-  this._realloc(arr.length * 4);
-  if (arr instanceof Float32Array &&
-      this.byteOffset+this.position % arr.BYTES_PER_ELEMENT == 0) {
-    DataStream.memcpy(this._buffer, this.byteOffset+this.position,
-                      arr.buffer, 0,
-                      arr.byteLength);
-    this.mapFloat32Array(arr.length, e);
-  } else {
-    for (var i=0; i<arr.length; i++) {
-      this.writeFloat32(arr[i], e);
-    }
-  }
-};
-
-
-/**
-  Reads a 32-bit int from the DataStream with the desired endianness.
-
-  @param {?boolean} e Endianness of the number.
-  @return {number} The read number.
- */
-DataStream.prototype.readInt32 = function(e) {
-  var v = this._dataView.getInt32(this.position, e == null ? this.endianness : e);
-  this.position += 4;
-  return v;
-};
-
-/**
-  Reads a 16-bit int from the DataStream with the desired endianness.
-
-  @param {?boolean} e Endianness of the number.
-  @return {number} The read number.
- */
-DataStream.prototype.readInt16 = function(e) {
-  var v = this._dataView.getInt16(this.position, e == null ? this.endianness : e);
-  this.position += 2;
-  return v;
-};
-
-/**
-  Reads an 8-bit int from the DataStream.
-
-  @return {number} The read number.
- */
-DataStream.prototype.readInt8 = function() {
-  var v = this._dataView.getInt8(this.position);
-  this.position += 1;
-  return v;
-};
-
-/**
-  Reads a 32-bit unsigned int from the DataStream with the desired endianness.
-
-  @param {?boolean} e Endianness of the number.
-  @return {number} The read number.
- */
-DataStream.prototype.readUint32 = function(e) {
-  var v = this._dataView.getUint32(this.position, e == null ? this.endianness : e);
-  this.position += 4;
-  return v;
-};
-
-/**
-  Reads a 16-bit unsigned int from the DataStream with the desired endianness.
-
-  @param {?boolean} e Endianness of the number.
-  @return {number} The read number.
- */
-DataStream.prototype.readUint16 = function(e) {
-  var v = this._dataView.getUint16(this.position, e == null ? this.endianness : e);
-  this.position += 2;
-  return v;
-};
-
-/**
-  Reads an 8-bit unsigned int from the DataStream.
-
-  @return {number} The read number.
- */
-DataStream.prototype.readUint8 = function() {
-  var v = this._dataView.getUint8(this.position);
-  this.position += 1;
-  return v;
-};
-
-/**
-  Reads a 32-bit float from the DataStream with the desired endianness.
-
-  @param {?boolean} e Endianness of the number.
-  @return {number} The read number.
- */
-DataStream.prototype.readFloat32 = function(e) {
-  var v = this._dataView.getFloat32(this.position, e == null ? this.endianness : e);
-  this.position += 4;
-  return v;
-};
-
-/**
-  Reads a 64-bit float from the DataStream with the desired endianness.
-
-  @param {?boolean} e Endianness of the number.
-  @return {number} The read number.
- */
-DataStream.prototype.readFloat64 = function(e) {
-  var v = this._dataView.getFloat64(this.position, e == null ? this.endianness : e);
-  this.position += 8;
-  return v;
-};
-
-
-/**
-  Writes a 32-bit int to the DataStream with the desired endianness.
-
-  @param {number} v Number to write.
-  @param {?boolean} e Endianness of the number.
- */
-DataStream.prototype.writeInt32 = function(v, e) {
-  this._realloc(4);
-  this._dataView.setInt32(this.position, v, e == null ? this.endianness : e);
-  this.position += 4;
-};
-
-/**
-  Writes a 16-bit int to the DataStream with the desired endianness.
-
-  @param {number} v Number to write.
-  @param {?boolean} e Endianness of the number.
- */
-DataStream.prototype.writeInt16 = function(v, e) {
-  this._realloc(2);
-  this._dataView.setInt16(this.position, v, e == null ? this.endianness : e);
-  this.position += 2;
-};
-
-/**
-  Writes an 8-bit int to the DataStream.
-
-  @param {number} v Number to write.
- */
-DataStream.prototype.writeInt8 = function(v) {
-  this._realloc(1);
-  this._dataView.setInt8(this.position, v);
-  this.position += 1;
-};
-
-/**
-  Writes a 32-bit unsigned int to the DataStream with the desired endianness.
-
-  @param {number} v Number to write.
-  @param {?boolean} e Endianness of the number.
- */
-DataStream.prototype.writeUint32 = function(v, e) {
-  this._realloc(4);
-  this._dataView.setUint32(this.position, v, e == null ? this.endianness : e);
-  this.position += 4;
-};
-
-/**
-  Writes a 16-bit unsigned int to the DataStream with the desired endianness.
-
-  @param {number} v Number to write.
-  @param {?boolean} e Endianness of the number.
- */
-DataStream.prototype.writeUint16 = function(v, e) {
-  this._realloc(2);
-  this._dataView.setUint16(this.position, v, e == null ? this.endianness : e);
-  this.position += 2;
-};
-
-/**
-  Writes an 8-bit unsigned  int to the DataStream.
-
-  @param {number} v Number to write.
- */
-DataStream.prototype.writeUint8 = function(v) {
-  this._realloc(1);
-  this._dataView.setUint8(this.position, v);
-  this.position += 1;
-};
-
-/**
-  Writes a 32-bit float to the DataStream with the desired endianness.
-
-  @param {number} v Number to write.
-  @param {?boolean} e Endianness of the number.
- */
-DataStream.prototype.writeFloat32 = function(v, e) {
-  this._realloc(4);
-  this._dataView.setFloat32(this.position, v, e == null ? this.endianness : e);
-  this.position += 4;
-};
-
-/**
-  Writes a 64-bit float to the DataStream with the desired endianness.
-
-  @param {number} v Number to write.
-  @param {?boolean} e Endianness of the number.
- */
-DataStream.prototype.writeFloat64 = function(v, e) {
-  this._realloc(8);
-  this._dataView.setFloat64(this.position, v, e == null ? this.endianness : e);
-  this.position += 8;
-};
-
-/**
-  Native endianness. Either DataStream.BIG_ENDIAN or DataStream.LITTLE_ENDIAN
-  depending on the platform endianness.
-
-  @type {boolean}
- */
-DataStream.endianness = new Int8Array(new Int16Array([1]).buffer)[0] > 0;
-
-/**
-  Copies byteLength bytes from the src buffer at srcOffset to the
-  dst buffer at dstOffset.
-
-  @param {Object} dst Destination ArrayBuffer to write to.
-  @param {number} dstOffset Offset to the destination ArrayBuffer.
-  @param {Object} src Source ArrayBuffer to read from.
-  @param {number} srcOffset Offset to the source ArrayBuffer.
-  @param {number} byteLength Number of bytes to copy.
- */
-DataStream.memcpy = function(dst, dstOffset, src, srcOffset, byteLength) {
-  var dstU8 = new Uint8Array(dst, dstOffset, byteLength);
-  var srcU8 = new Uint8Array(src, srcOffset, byteLength);
-  dstU8.set(srcU8);
-};
-
-/**
-  Converts array to native endianness in-place.
-
-  @param {Object} array Typed array to convert.
-  @param {boolean} arrayIsLittleEndian True if the data in the array is
-                                       little-endian. Set false for big-endian.
-  @return {Object} The converted typed array.
- */
-DataStream.arrayToNative = function(array, arrayIsLittleEndian) {
-  if (arrayIsLittleEndian == this.endianness) {
-    return array;
-  } else {
-    return this.flipArrayEndianness(array);
-  }
-};
-
-/**
-  Converts native endianness array to desired endianness in-place.
-
-  @param {Object} array Typed array to convert.
-  @param {boolean} littleEndian True if the converted array should be
-                                little-endian. Set false for big-endian.
-  @return {Object} The converted typed array.
- */
-DataStream.nativeToEndian = function(array, littleEndian) {
-  if (this.endianness == littleEndian) {
-    return array;
-  } else {
-    return this.flipArrayEndianness(array);
-  }
-};
-
-/**
-  Flips typed array endianness in-place.
-
-  @param {Object} array Typed array to flip.
-  @return {Object} The converted typed array.
- */
-DataStream.flipArrayEndianness = function(array) {
-  var u8 = new Uint8Array(array.buffer, array.byteOffset, array.byteLength);
-  for (var i=0; i<array.byteLength; i+=array.BYTES_PER_ELEMENT) {
-    for (var j=i+array.BYTES_PER_ELEMENT-1, k=i; j>k; j--, k++) {
-      var tmp = u8[k];
-      u8[k] = u8[j];
-      u8[j] = tmp;
-    }
-  }
-  return array;
-};
-
-/**
-  Creates an array from an array of character codes.
-  Uses String.fromCharCode on the character codes and concats the results into a string.
-
-  @param {array} array Array of character codes.
-  @return {string} String created from the character codes.
-**/
-DataStream.createStringFromArray = function(array) {
-  var str = "";
-  for (var i=0; i<array.length; i++) {
-    str += String.fromCharCode(array[i]);
-  }
-  return str;
-};
-
-/**
-  Seek position where DataStream#readStruct ran into a problem.
-  Useful for debugging struct parsing.
-
-  @type {number}
- */
-DataStream.prototype.failurePosition = 0;
-
-/**
-  Reads a struct of data from the DataStream. The struct is defined as
-  a flat array of [name, type]-pairs. See the example below:
-
-  ds.readStruct([
-    'headerTag', 'uint32', // Uint32 in DataStream endianness.
-    'headerTag2', 'uint32be', // Big-endian Uint32.
-    'headerTag3', 'uint32le', // Little-endian Uint32.
-    'array', ['[]', 'uint32', 16], // Uint32Array of length 16.
-    'array2Length', 'uint32',
-    'array2', ['[]', 'uint32', 'array2Length'] // Uint32Array of length array2Length
-  ]);
-
-  The possible values for the type are as follows:
-
-  // Number types
-
-  // Unsuffixed number types use DataStream endianness.
-  // To explicitly specify endianness, suffix the type with
-  // 'le' for little-endian or 'be' for big-endian,
-  // e.g. 'int32be' for big-endian int32.
-
-  'uint8' -- 8-bit unsigned int
-  'uint16' -- 16-bit unsigned int
-  'uint32' -- 32-bit unsigned int
-  'int8' -- 8-bit int
-  'int16' -- 16-bit int
-  'int32' -- 32-bit int
-  'float32' -- 32-bit float
-  'float64' -- 64-bit float
-
-  // String types
-  'cstring' -- ASCII string terminated by a zero byte.
-  'string:N' -- ASCII string of length N, where N is a literal integer.
-  'string:variableName' -- ASCII string of length $variableName,
-    where 'variableName' is a previously parsed number in the current struct.
-  'string,CHARSET:N' -- String of byteLength N encoded with given CHARSET.
-  'u16string:N' -- UCS-2 string of length N in DataStream endianness.
-  'u16stringle:N' -- UCS-2 string of length N in little-endian.
-  'u16stringbe:N' -- UCS-2 string of length N in big-endian.
-
-  // Complex types
-  [name, type, name_2, type_2, ..., name_N, type_N] -- Struct
-  function(dataStream, struct) {} -- Callback function to read and return data.
-  {get: function(dataStream, struct) {},
-   set: function(dataStream, struct) {}}
-  -- Getter/setter functions to read and return data, handy for using the same
-     struct definition for reading and writing structs.
-  ['[]', type, length] -- Array of given type and length. The length can be either
-                        a number, a string that references a previously-read
-                        field, or a callback function(struct, dataStream, type){}.
-                        If length is '*', reads in as many elements as it can.
-
-  @param {Object} structDefinition Struct definition object.
-  @return {Object} The read struct. Null if failed to read struct.
- */
-DataStream.prototype.readStruct = function(structDefinition) {
-  var struct = {}, t, v, n;
-  var p = this.position;
-  for (var i=0; i<structDefinition.length; i+=2) {
-    t = structDefinition[i+1];
-    v = this.readType(t, struct);
-    if (v == null) {
-      if (this.failurePosition == 0) {
-        this.failurePosition = this.position;
-      }
-      this.position = p;
-      return null;
-    }
-    struct[structDefinition[i]] = v;
-  }
-  return struct;
-};
-
-/**
-  Read UCS-2 string of desired length and endianness from the DataStream.
-
-  @param {number} length The length of the string to read.
-  @param {boolean} endianness The endianness of the string data in the DataStream.
-  @return {string} The read string.
- */
-DataStream.prototype.readUCS2String = function(length, endianness) {
-  return DataStream.createStringFromArray(this.readUint16Array(length, endianness));
-};
-
-/**
-  Write a UCS-2 string of desired endianness to the DataStream. The
-  lengthOverride argument lets you define the number of characters to write.
-  If the string is shorter than lengthOverride, the extra space is padded with
-  zeroes.
-
-  @param {string} str The string to write.
-  @param {?boolean} endianness The endianness to use for the written string data.
-  @param {?number} lengthOverride The number of characters to write.
- */
-DataStream.prototype.writeUCS2String = function(str, endianness, lengthOverride) {
-  if (lengthOverride == null) {
-    lengthOverride = str.length;
-  }
-  for (var i = 0; i < str.length && i < lengthOverride; i++) {
-    this.writeUint16(str.charCodeAt(i), endianness);
-  }
-  for (; i<lengthOverride; i++) {
-    this.writeUint16(0);
-  }
-};
-
-/**
-  Read a string of desired length and encoding from the DataStream.
-
-  @param {number} length The length of the string to read in bytes.
-  @param {?string} encoding The encoding of the string data in the DataStream.
-                            Defaults to ASCII.
-  @return {string} The read string.
- */
-DataStream.prototype.readString = function(length, encoding) {
-  if (encoding == null || encoding == "ASCII") {
-    return DataStream.createStringFromArray(this.mapUint8Array(length == null ? this.byteLength-this.position : length));
-  } else {
-    return (new TextDecoder(encoding)).decode(this.mapUint8Array(length));
-  }
-};
-
-/**
-  Writes a string of desired length and encoding to the DataStream.
-
-  @param {string} s The string to write.
-  @param {?string} encoding The encoding for the written string data.
-                            Defaults to ASCII.
-  @param {?number} length The number of characters to write.
- */
-DataStream.prototype.writeString = function(s, encoding, length) {
-  if (encoding == null || encoding == "ASCII") {
-    if (length != null) {
-      var i = 0;
-      var len = Math.min(s.length, length);
-      for (i=0; i<len; i++) {
-        this.writeUint8(s.charCodeAt(i));
-      }
-      for (; i<length; i++) {
-        this.writeUint8(0);
-      }
-    } else {
-      for (var i=0; i<s.length; i++) {
-        this.writeUint8(s.charCodeAt(i));
-      }
-    }
-  } else {
-    this.writeUint8Array((new TextEncoder(encoding)).encode(s.substring(0, length)));
-  }
-};
-
-
-/**
-  Read null-terminated string of desired length from the DataStream. Truncates
-  the returned string so that the null byte is not a part of it.
-
-  @param {?number} length The length of the string to read.
-  @return {string} The read string.
- */
-DataStream.prototype.readCString = function(length) {
-  var blen = this.byteLength-this.position;
-  var u8 = new Uint8Array(this._buffer, this._byteOffset + this.position);
-  var len = blen;
-  if (length != null) {
-    len = Math.min(length, blen);
-  }
-  for (var i = 0; i < len && u8[i] != 0; i++); // find first zero byte
-  var s = DataStream.createStringFromArray(this.mapUint8Array(i));
-  if (length != null) {
-    this.position += len-i;
-  } else if (i != blen) {
-    this.position += 1; // trailing zero if not at end of buffer
-  }
-  return s;
-};
-
-/**
-  Writes a null-terminated string to DataStream and zero-pads it to length
-  bytes. If length is not given, writes the string followed by a zero.
-  If string is longer than length, the written part of the string does not have
-  a trailing zero.
-
-  @param {string} s The string to write.
-  @param {?number} length The number of characters to write.
- */
-DataStream.prototype.writeCString = function(s, length) {
-  if (length != null) {
-    var i = 0;
-    var len = Math.min(s.length, length);
-    for (i=0; i<len; i++) {
-      this.writeUint8(s.charCodeAt(i));
-    }
-    for (; i<length; i++) {
-      this.writeUint8(0);
-    }
-  } else {
-    for (var i=0; i<s.length; i++) {
-      this.writeUint8(s.charCodeAt(i));
-    }
-    this.writeUint8(0);
-  }
-};
-
-/**
-  Reads an object of type t from the DataStream, passing struct as the thus-far
-  read struct to possible callbacks that refer to it. Used by readStruct for
-  reading in the values, so the type is one of the readStruct types.
-
-  @param {Object} t Type of the object to read.
-  @param {?Object} struct Struct to refer to when resolving length references
-                          and for calling callbacks.
-  @return {?Object} Returns the object on successful read, null on unsuccessful.
- */
-DataStream.prototype.readType = function(t, struct) {
-  if (typeof t == "function") {
-    return t(this, struct);
-  } else if (typeof t == "object" && !(t instanceof Array)) {
-    return t.get(this, struct);
-  } else if (t instanceof Array && t.length != 3) {
-    return this.readStruct(t, struct);
-  }
-  var v = null;
-  var lengthOverride = null;
-  var charset = "ASCII";
-  var pos = this.position;
-  var len;
-  if (typeof t == 'string' && /:/.test(t)) {
-    var tp = t.split(":");
-    t = tp[0];
-    len = tp[1];
-
-    // allow length to be previously parsed variable
-    // e.g. 'string:fieldLength', if `fieldLength` has
-    // been parsed previously.
-    if (struct[len] != null) {
-      lengthOverride = parseInt(struct[len]);
-    } else {
-      // assume literal integer e.g., 'string:4'
-      lengthOverride = parseInt(tp[1]);
-    }
-  }
-  if (typeof t == 'string' && /,/.test(t)) {
-    var tp = t.split(",");
-    t = tp[0];
-    charset = parseInt(tp[1]);
-  }
-  switch(t) {
-
-    case 'uint8':
-      v = this.readUint8(); break;
-    case 'int8':
-      v = this.readInt8(); break;
-
-    case 'uint16':
-      v = this.readUint16(this.endianness); break;
-    case 'int16':
-      v = this.readInt16(this.endianness); break;
-    case 'uint32':
-      v = this.readUint32(this.endianness); break;
-    case 'int32':
-      v = this.readInt32(this.endianness); break;
-    case 'float32':
-      v = this.readFloat32(this.endianness); break;
-    case 'float64':
-      v = this.readFloat64(this.endianness); break;
-
-    case 'uint16be':
-      v = this.readUint16(DataStream.BIG_ENDIAN); break;
-    case 'int16be':
-      v = this.readInt16(DataStream.BIG_ENDIAN); break;
-    case 'uint32be':
-      v = this.readUint32(DataStream.BIG_ENDIAN); break;
-    case 'int32be':
-      v = this.readInt32(DataStream.BIG_ENDIAN); break;
-    case 'float32be':
-      v = this.readFloat32(DataStream.BIG_ENDIAN); break;
-    case 'float64be':
-      v = this.readFloat64(DataStream.BIG_ENDIAN); break;
-
-    case 'uint16le':
-      v = this.readUint16(DataStream.LITTLE_ENDIAN); break;
-    case 'int16le':
-      v = this.readInt16(DataStream.LITTLE_ENDIAN); break;
-    case 'uint32le':
-      v = this.readUint32(DataStream.LITTLE_ENDIAN); break;
-    case 'int32le':
-      v = this.readInt32(DataStream.LITTLE_ENDIAN); break;
-    case 'float32le':
-      v = this.readFloat32(DataStream.LITTLE_ENDIAN); break;
-    case 'float64le':
-      v = this.readFloat64(DataStream.LITTLE_ENDIAN); break;
-
-    case 'cstring':
-      v = this.readCString(lengthOverride); break;
-
-    case 'string':
-      v = this.readString(lengthOverride, charset); break;
-
-    case 'u16string':
-      v = this.readUCS2String(lengthOverride, this.endianness); break;
-
-    case 'u16stringle':
-      v = this.readUCS2String(lengthOverride, DataStream.LITTLE_ENDIAN); break;
-
-    case 'u16stringbe':
-      v = this.readUCS2String(lengthOverride, DataStream.BIG_ENDIAN); break;
-
-    default:
-      if (t.length == 3) {
-        var ta = t[1];
-        var len = t[2];
-        var length = 0;
-        if (typeof len == 'function') {
-          length = len(struct, this, t);
-        } else if (typeof len == 'string' && struct[len] != null) {
-          length = parseInt(struct[len]);
-        } else {
-          length = parseInt(len);
-        }
-        if (typeof ta == "string") {
-          var tap = ta.replace(/(le|be)$/, '');
-          var endianness = null;
-          if (/le$/.test(ta)) {
-            endianness = DataStream.LITTLE_ENDIAN;
-          } else if (/be$/.test(ta)) {
-            endianness = DataStream.BIG_ENDIAN;
-          }
-          if (len == '*') {
-            length = null;
-          }
-          switch(tap) {
-            case 'uint8':
-              v = this.readUint8Array(length); break;
-            case 'uint16':
-              v = this.readUint16Array(length, endianness); break;
-            case 'uint32':
-              v = this.readUint32Array(length, endianness); break;
-            case 'int8':
-              v = this.readInt8Array(length); break;
-            case 'int16':
-              v = this.readInt16Array(length, endianness); break;
-            case 'int32':
-              v = this.readInt32Array(length, endianness); break;
-            case 'float32':
-              v = this.readFloat32Array(length, endianness); break;
-            case 'float64':
-              v = this.readFloat64Array(length, endianness); break;
-            case 'cstring':
-            case 'utf16string':
-            case 'string':
-              if (length == null) {
-                v = [];
-                while (!this.isEof()) {
-                  var u = this.readType(ta, struct);
-                  if (u == null) break;
-                  v.push(u);
-                }
-              } else {
-                v = new Array(length);
-                for (var i=0; i<length; i++) {
-                  v[i] = this.readType(ta, struct);
-                }
-              }
-              break;
-          }
-        } else {
-          if (len == '*') {
-            v = [];
-            this.buffer;
-            while (true) {
-              var p = this.position;
-              try {
-                var o = this.readType(ta, struct);
-                if (o == null) {
-                  this.position = p;
-                  break;
-                }
-                v.push(o);
-              } catch(e) {
-                this.position = p;
-                break;
-              }
-            }
-          } else {
-            v = new Array(length);
-            for (var i=0; i<length; i++) {
-              var u = this.readType(ta, struct);
-              if (u == null) return null;
-              v[i] = u;
-            }
-          }
-        }
-        break;
-      }
-  }
-  if (lengthOverride != null) {
-    this.position = pos + lengthOverride;
-  }
-  return v;
-};
-
-/**
-  Writes a struct to the DataStream. Takes a structDefinition that gives the
-  types and a struct object that gives the values. Refer to readStruct for the
-  structure of structDefinition.
-
-  @param {Object} structDefinition Type definition of the struct.
-  @param {Object} struct The struct data object.
-  */
-DataStream.prototype.writeStruct = function(structDefinition, struct) {
-  for (var i = 0; i < structDefinition.length; i+=2) {
-    var t = structDefinition[i+1];
-    this.writeType(t, struct[structDefinition[i]], struct);
-  }
-};
-
-/**
-  Writes object v of type t to the DataStream.
-
-  @param {Object} t Type of data to write.
-  @param {Object} v Value of data to write.
-  @param {Object} struct Struct to pass to write callback functions.
-  */
-DataStream.prototype.writeType = function(t, v, struct) {
-  if (typeof t == "function") {
-    return t(this, v);
-  } else if (typeof t == "object" && !(t instanceof Array)) {
-    return t.set(this, v, struct);
-  }
-  var lengthOverride = null;
-  var charset = "ASCII";
-  var pos = this.position;
-  if (typeof(t) == 'string' && /:/.test(t)) {
-    var tp = t.split(":");
-    t = tp[0];
-    lengthOverride = parseInt(tp[1]);
-  }
-  if (typeof t == 'string' && /,/.test(t)) {
-    var tp = t.split(",");
-    t = tp[0];
-    charset = parseInt(tp[1]);
-  }
-
-  switch(t) {
-    case 'uint8':
-      this.writeUint8(v);
-      break;
-    case 'int8':
-      this.writeInt8(v);
-      break;
-
-    case 'uint16':
-      this.writeUint16(v, this.endianness);
-      break;
-    case 'int16':
-      this.writeInt16(v, this.endianness);
-      break;
-    case 'uint32':
-      this.writeUint32(v, this.endianness);
-      break;
-    case 'int32':
-      this.writeInt32(v, this.endianness);
-      break;
-    case 'float32':
-      this.writeFloat32(v, this.endianness);
-      break;
-    case 'float64':
-      this.writeFloat64(v, this.endianness);
-      break;
-
-    case 'uint16be':
-      this.writeUint16(v, DataStream.BIG_ENDIAN);
-      break;
-    case 'int16be':
-      this.writeInt16(v, DataStream.BIG_ENDIAN);
-      break;
-    case 'uint32be':
-      this.writeUint32(v, DataStream.BIG_ENDIAN);
-      break;
-    case 'int32be':
-      this.writeInt32(v, DataStream.BIG_ENDIAN);
-      break;
-    case 'float32be':
-      this.writeFloat32(v, DataStream.BIG_ENDIAN);
-      break;
-    case 'float64be':
-      this.writeFloat64(v, DataStream.BIG_ENDIAN);
-      break;
-
-    case 'uint16le':
-      this.writeUint16(v, DataStream.LITTLE_ENDIAN);
-      break;
-    case 'int16le':
-      this.writeInt16(v, DataStream.LITTLE_ENDIAN);
-      break;
-    case 'uint32le':
-      this.writeUint32(v, DataStream.LITTLE_ENDIAN);
-      break;
-    case 'int32le':
-      this.writeInt32(v, DataStream.LITTLE_ENDIAN);
-      break;
-    case 'float32le':
-      this.writeFloat32(v, DataStream.LITTLE_ENDIAN);
-      break;
-    case 'float64le':
-      this.writeFloat64(v, DataStream.LITTLE_ENDIAN);
-      break;
-
-    case 'cstring':
-      this.writeCString(v, lengthOverride);
-      break;
-
-    case 'string':
-      this.writeString(v, charset, lengthOverride);
-      break;
-
-    case 'u16string':
-      this.writeUCS2String(v, this.endianness, lengthOverride);
-      break;
-
-    case 'u16stringle':
-      this.writeUCS2String(v, DataStream.LITTLE_ENDIAN, lengthOverride);
-      break;
-
-    case 'u16stringbe':
-      this.writeUCS2String(v, DataStream.BIG_ENDIAN, lengthOverride);
-      break;
-
-    default:
-      if (t.length == 3) {
-        var ta = t[1];
-        for (var i=0; i<v.length; i++) {
-          this.writeType(ta, v[i]);
-        }
-        break;
-      } else {
-        this.writeStruct(t, v);
-        break;
-      }
-  }
-  if (lengthOverride != null) {
-    this.position = pos;
-    this._realloc(lengthOverride);
-    this.position = pos + lengthOverride;
-  }
-};
-
-// Export DataStream for amd environments
-if (typeof define === 'function' && define.amd) {
-    define('DataStream', [], function() {
-      return DataStream;
-    });
-  }
-  
-// Export DataStream for CommonJS
-if (typeof module === 'object' && module && module.exports) {
-  module.exports = DataStream;
-}
-
diff --git a/resources/js/MapHelper.js b/resources/js/MapHelper.js
deleted file mode 100644
index 2af8fd3..0000000
--- a/resources/js/MapHelper.js
+++ /dev/null
@@ -1,1565 +0,0 @@
-function rgb(r, g, b) {
-  return {
-    r: r,
-    g: g,
-    b: b,
-  };
-}
-
-// Decompiled from the Terraria source code
-
-var tileColors = new Array(753);
-var liquidColors = new Array(4);
-var wallColors = new Array(367);
-
-for (var i = 0; i < tileColors.length; i++) {
-  tileColors[i] = new Array(13);
-}
-
-tileColors[656][0] = rgb(21, 124, 212);
-tileColors[701][0] = tileColors[656][0];
-tileColors[624][0] = rgb(210, 91, 77);
-tileColors[700][0] = tileColors[624][0];
-tileColors[621][0] = rgb(250, 250, 250);
-tileColors[622][0] = rgb(235, 235, 249);
-tileColors[518][0] = rgb(26, 196, 84);
-tileColors[518][1] = rgb(48, 208, 234);
-tileColors[518][2] = rgb(135, 196, 26);
-tileColors[519][0] = rgb(28, 216, 109);
-tileColors[519][1] = rgb(107, 182, 0);
-tileColors[519][2] = rgb(75, 184, 230);
-tileColors[519][3] = rgb(208, 80, 80);
-tileColors[519][4] = rgb(141, 137, 223);
-tileColors[519][5] = rgb(182, 175, 130);
-tileColors[549][0] = rgb(54, 83, 20);
-tileColors[528][0] = rgb(182, 175, 130);
-tileColors[529][0] = rgb(99, 150, 8);
-tileColors[529][1] = rgb(139, 154, 64);
-tileColors[529][2] = rgb(34, 129, 168);
-tileColors[529][3] = rgb(180, 82, 82);
-tileColors[529][4] = rgb(113, 108, 205);
-var color = rgb(151, 107, 75);
-tileColors[0][0] = color;
-tileColors[668][0] = color;
-tileColors[5][0] = color;
-tileColors[5][1] = rgb(182, 175, 130);
-var color2 = rgb(127, 127, 127);
-tileColors[583][0] = color2;
-tileColors[584][0] = color2;
-tileColors[585][0] = color2;
-tileColors[586][0] = color2;
-tileColors[587][0] = color2;
-tileColors[588][0] = color2;
-tileColors[589][0] = color2;
-tileColors[590][0] = color2;
-tileColors[595][0] = color;
-tileColors[596][0] = color;
-tileColors[615][0] = color;
-tileColors[616][0] = color;
-tileColors[634][0] = rgb(145, 120, 120);
-tileColors[633][0] = rgb(210, 140, 100);
-tileColors[637][0] = rgb(200, 120, 75);
-tileColors[638][0] = rgb(200, 120, 75);
-tileColors[30][0] = color;
-tileColors[191][0] = color;
-tileColors[272][0] = rgb(121, 119, 101);
-color = rgb(128, 128, 128);
-tileColors[1][0] = color;
-tileColors[38][0] = color;
-tileColors[48][0] = color;
-tileColors[130][0] = color;
-tileColors[138][0] = color;
-tileColors[664][0] = color;
-tileColors[711][0] = color;
-tileColors[712][0] = color;
-tileColors[713][0] = color;
-tileColors[714][0] = color;
-tileColors[715][0] = color;
-tileColors[716][0] = color;
-tileColors[273][0] = color;
-tileColors[283][0] = color;
-tileColors[618][0] = color;
-tileColors[654][0] = rgb(200, 44, 28);
-tileColors[2][0] = rgb(28, 216, 94);
-tileColors[477][0] = rgb(28, 216, 94);
-tileColors[492][0] = rgb(78, 193, 227);
-color = rgb(26, 196, 84);
-tileColors[3][0] = color;
-tileColors[192][0] = color;
-tileColors[73][0] = rgb(27, 197, 109);
-tileColors[52][0] = rgb(23, 177, 76);
-tileColors[353][0] = rgb(28, 216, 94);
-tileColors[20][0] = rgb(163, 116, 81);
-tileColors[6][0] = rgb(140, 101, 80);
-color = rgb(150, 67, 22);
-tileColors[7][0] = color;
-tileColors[47][0] = color;
-tileColors[284][0] = color;
-tileColors[682][0] = color;
-tileColors[560][0] = color;
-color = rgb(185, 164, 23);
-tileColors[8][0] = color;
-tileColors[45][0] = color;
-tileColors[680][0] = color;
-tileColors[560][2] = color;
-color = rgb(185, 194, 195);
-tileColors[9][0] = color;
-tileColors[46][0] = color;
-tileColors[681][0] = color;
-tileColors[560][1] = color;
-color = rgb(98, 95, 167);
-tileColors[22][0] = color;
-tileColors[140][0] = color;
-tileColors[23][0] = rgb(141, 137, 223);
-tileColors[24][0] = rgb(122, 116, 218);
-tileColors[636][0] = rgb(122, 116, 218);
-tileColors[25][0] = rgb(109, 90, 128);
-tileColors[37][0] = rgb(104, 86, 84);
-tileColors[39][0] = rgb(181, 62, 59);
-tileColors[40][0] = rgb(146, 81, 68);
-tileColors[41][0] = rgb(66, 84, 109);
-tileColors[677][0] = rgb(66, 84, 109);
-tileColors[481][0] = rgb(66, 84, 109);
-tileColors[43][0] = rgb(84, 100, 63);
-tileColors[678][0] = rgb(84, 100, 63);
-tileColors[482][0] = rgb(84, 100, 63);
-tileColors[44][0] = rgb(107, 68, 99);
-tileColors[679][0] = rgb(107, 68, 99);
-tileColors[483][0] = rgb(107, 68, 99);
-tileColors[53][0] = rgb(186, 168, 84);
-color = rgb(190, 171, 94);
-tileColors[151][0] = color;
-tileColors[154][0] = color;
-tileColors[274][0] = color;
-tileColors[328][0] = rgb(200, 246, 254);
-tileColors[329][0] = rgb(15, 15, 15);
-tileColors[54][0] = rgb(200, 246, 254);
-tileColors[56][0] = rgb(43, 40, 84);
-tileColors[75][0] = rgb(26, 26, 26);
-tileColors[683][0] = rgb(100, 90, 190);
-tileColors[57][0] = rgb(68, 68, 76);
-color = rgb(142, 66, 66);
-tileColors[58][0] = color;
-tileColors[76][0] = color;
-tileColors[684][0] = color;
-color = rgb(92, 68, 73);
-tileColors[59][0] = color;
-tileColors[120][0] = color;
-tileColors[60][0] = rgb(143, 215, 29);
-tileColors[61][0] = rgb(135, 196, 26);
-tileColors[703][0] = tileColors[61][0];
-tileColors[74][0] = rgb(96, 197, 27);
-tileColors[62][0] = rgb(121, 176, 24);
-tileColors[233][0] = rgb(107, 182, 29);
-tileColors[652][0] = tileColors[233][0];
-tileColors[651][0] = tileColors[233][0];
-tileColors[63][0] = rgb(110, 140, 182);
-tileColors[64][0] = rgb(196, 96, 114);
-tileColors[65][0] = rgb(56, 150, 97);
-tileColors[66][0] = rgb(160, 118, 58);
-tileColors[67][0] = rgb(140, 58, 166);
-tileColors[68][0] = rgb(125, 191, 197);
-tileColors[566][0] = rgb(233, 180, 90);
-tileColors[70][0] = rgb(93, 127, 255);
-color = rgb(182, 175, 130);
-tileColors[71][0] = color;
-tileColors[72][0] = color;
-tileColors[190][0] = color;
-tileColors[578][0] = rgb(172, 155, 110);
-color = rgb(73, 120, 17);
-tileColors[80][0] = color;
-tileColors[484][0] = color;
-tileColors[188][0] = color;
-tileColors[80][1] = rgb(87, 84, 151);
-tileColors[80][2] = rgb(34, 129, 168);
-tileColors[80][3] = rgb(130, 56, 55);
-color = rgb(11, 80, 143);
-tileColors[107][0] = color;
-tileColors[121][0] = color;
-tileColors[685][0] = color;
-color = rgb(91, 169, 169);
-tileColors[108][0] = color;
-tileColors[122][0] = color;
-tileColors[686][0] = color;
-color = rgb(128, 26, 52);
-tileColors[111][0] = color;
-tileColors[150][0] = color;
-tileColors[109][0] = rgb(78, 193, 227);
-tileColors[110][0] = rgb(48, 186, 135);
-tileColors[113][0] = rgb(48, 208, 234);
-tileColors[115][0] = rgb(33, 171, 207);
-tileColors[112][0] = rgb(103, 98, 122);
-color = rgb(238, 225, 218);
-tileColors[116][0] = color;
-tileColors[118][0] = color;
-tileColors[117][0] = rgb(181, 172, 190);
-tileColors[119][0] = rgb(107, 92, 108);
-tileColors[123][0] = rgb(106, 107, 118);
-tileColors[124][0] = rgb(73, 51, 36);
-tileColors[131][0] = rgb(52, 52, 52);
-tileColors[145][0] = rgb(192, 30, 30);
-tileColors[146][0] = rgb(43, 192, 30);
-color = rgb(211, 236, 241);
-tileColors[147][0] = color;
-tileColors[148][0] = color;
-tileColors[152][0] = rgb(128, 133, 184);
-tileColors[153][0] = rgb(239, 141, 126);
-tileColors[155][0] = rgb(131, 162, 161);
-tileColors[156][0] = rgb(170, 171, 157);
-tileColors[157][0] = rgb(104, 100, 126);
-color = rgb(145, 81, 85);
-tileColors[158][0] = color;
-tileColors[232][0] = color;
-tileColors[575][0] = rgb(125, 61, 65);
-tileColors[159][0] = rgb(148, 133, 98);
-tileColors[161][0] = rgb(144, 195, 232);
-tileColors[162][0] = rgb(184, 219, 240);
-tileColors[163][0] = rgb(174, 145, 214);
-tileColors[164][0] = rgb(218, 182, 204);
-tileColors[170][0] = rgb(27, 109, 69);
-tileColors[171][0] = rgb(33, 135, 85);
-color = rgb(129, 125, 93);
-tileColors[166][0] = color;
-tileColors[175][0] = color;
-tileColors[167][0] = rgb(62, 82, 114);
-color = rgb(132, 157, 127);
-tileColors[168][0] = color;
-tileColors[176][0] = color;
-color = rgb(152, 171, 198);
-tileColors[169][0] = color;
-tileColors[177][0] = color;
-tileColors[179][0] = rgb(49, 134, 114);
-tileColors[180][0] = rgb(126, 134, 49);
-tileColors[181][0] = rgb(134, 59, 49);
-tileColors[182][0] = rgb(43, 86, 140);
-tileColors[183][0] = rgb(121, 49, 134);
-tileColors[381][0] = rgb(254, 121, 2);
-tileColors[687][0] = rgb(254, 121, 2);
-tileColors[534][0] = rgb(114, 254, 2);
-tileColors[689][0] = rgb(114, 254, 2);
-tileColors[536][0] = rgb(0, 197, 208);
-tileColors[690][0] = rgb(0, 197, 208);
-tileColors[539][0] = rgb(208, 0, 126);
-tileColors[688][0] = rgb(208, 0, 126);
-tileColors[625][0] = rgb(220, 12, 237);
-tileColors[691][0] = rgb(220, 12, 237);
-tileColors[627][0] = rgb(255, 76, 76);
-tileColors[627][1] = rgb(255, 195, 76);
-tileColors[627][2] = rgb(195, 255, 76);
-tileColors[627][3] = rgb(76, 255, 76);
-tileColors[627][4] = rgb(76, 255, 195);
-tileColors[627][5] = rgb(76, 195, 255);
-tileColors[627][6] = rgb(77, 76, 255);
-tileColors[627][7] = rgb(196, 76, 255);
-tileColors[627][8] = rgb(255, 76, 195);
-tileColors[512][0] = rgb(49, 134, 114);
-tileColors[513][0] = rgb(126, 134, 49);
-tileColors[514][0] = rgb(134, 59, 49);
-tileColors[515][0] = rgb(43, 86, 140);
-tileColors[516][0] = rgb(121, 49, 134);
-tileColors[517][0] = rgb(254, 121, 2);
-tileColors[535][0] = rgb(114, 254, 2);
-tileColors[537][0] = rgb(0, 197, 208);
-tileColors[540][0] = rgb(208, 0, 126);
-tileColors[626][0] = rgb(220, 12, 237);
-for (var j = 0; j < tileColors[628].Length; j++)
-{
-  tileColors[628][j] = tileColors[627][j];
-}
-for (var k = 0; k < tileColors[692].Length; k++)
-{
-  tileColors[692][k] = tileColors[627][k];
-}
-for (var l = 0; l < tileColors[160].Length; l++)
-{
-  tileColors[160][l] = tileColors[627][l];
-}
-tileColors[184][0] = rgb(29, 106, 88);
-tileColors[184][1] = rgb(94, 100, 36);
-tileColors[184][2] = rgb(96, 44, 40);
-tileColors[184][3] = rgb(34, 63, 102);
-tileColors[184][4] = rgb(79, 35, 95);
-tileColors[184][5] = rgb(253, 62, 3);
-tileColors[184][6] = rgb(22, 123, 62);
-tileColors[184][7] = rgb(0, 106, 148);
-tileColors[184][8] = rgb(148, 0, 132);
-tileColors[184][9] = rgb(122, 24, 168);
-tileColors[184][10] = rgb(220, 20, 20);
-tileColors[189][0] = rgb(223, 255, 255);
-tileColors[193][0] = rgb(56, 121, 255);
-tileColors[194][0] = rgb(157, 157, 107);
-tileColors[195][0] = rgb(134, 22, 34);
-tileColors[196][0] = rgb(147, 144, 178);
-tileColors[197][0] = rgb(97, 200, 225);
-tileColors[198][0] = rgb(62, 61, 52);
-tileColors[199][0] = rgb(208, 80, 80);
-tileColors[201][0] = rgb(203, 61, 64);
-tileColors[205][0] = rgb(186, 50, 52);
-tileColors[200][0] = rgb(216, 152, 144);
-tileColors[202][0] = rgb(213, 178, 28);
-tileColors[203][0] = rgb(128, 44, 45);
-tileColors[204][0] = rgb(125, 55, 65);
-tileColors[206][0] = rgb(124, 175, 201);
-tileColors[208][0] = rgb(88, 105, 118);
-tileColors[211][0] = rgb(191, 233, 115);
-tileColors[213][0] = rgb(137, 120, 67);
-tileColors[214][0] = rgb(103, 103, 103);
-tileColors[221][0] = rgb(239, 90, 50);
-tileColors[222][0] = rgb(231, 96, 228);
-tileColors[223][0] = rgb(57, 85, 101);
-tileColors[224][0] = rgb(107, 132, 139);
-tileColors[225][0] = rgb(227, 125, 22);
-tileColors[226][0] = rgb(141, 56, 0);
-tileColors[229][0] = rgb(255, 156, 12);
-tileColors[659][0] = rgb(247, 228, 254);
-tileColors[230][0] = rgb(131, 79, 13);
-tileColors[234][0] = rgb(53, 44, 41);
-tileColors[235][0] = rgb(214, 184, 46);
-tileColors[236][0] = rgb(149, 232, 87);
-tileColors[702][0] = tileColors[236][0];
-tileColors[237][0] = rgb(255, 241, 51);
-tileColors[238][0] = rgb(225, 128, 206);
-tileColors[655][0] = rgb(225, 128, 206);
-tileColors[243][0] = rgb(198, 196, 170);
-tileColors[248][0] = rgb(219, 71, 38);
-tileColors[249][0] = rgb(235, 38, 231);
-tileColors[250][0] = rgb(86, 85, 92);
-tileColors[251][0] = rgb(235, 150, 23);
-tileColors[252][0] = rgb(153, 131, 44);
-tileColors[253][0] = rgb(57, 48, 97);
-tileColors[254][0] = rgb(248, 158, 92);
-tileColors[255][0] = rgb(107, 49, 154);
-tileColors[256][0] = rgb(154, 148, 49);
-tileColors[257][0] = rgb(49, 49, 154);
-tileColors[258][0] = rgb(49, 154, 68);
-tileColors[259][0] = rgb(154, 49, 77);
-tileColors[260][0] = rgb(85, 89, 118);
-tileColors[261][0] = rgb(154, 83, 49);
-tileColors[262][0] = rgb(221, 79, 255);
-tileColors[263][0] = rgb(250, 255, 79);
-tileColors[264][0] = rgb(79, 102, 255);
-tileColors[265][0] = rgb(79, 255, 89);
-tileColors[266][0] = rgb(255, 79, 79);
-tileColors[267][0] = rgb(240, 240, 247);
-tileColors[268][0] = rgb(255, 145, 79);
-tileColors[287][0] = rgb(79, 128, 17);
-color = rgb(122, 217, 232);
-tileColors[275][0] = color;
-tileColors[276][0] = color;
-tileColors[277][0] = color;
-tileColors[278][0] = color;
-tileColors[279][0] = color;
-tileColors[280][0] = color;
-tileColors[281][0] = color;
-tileColors[282][0] = color;
-tileColors[285][0] = color;
-tileColors[286][0] = color;
-tileColors[288][0] = color;
-tileColors[289][0] = color;
-tileColors[290][0] = color;
-tileColors[291][0] = color;
-tileColors[292][0] = color;
-tileColors[293][0] = color;
-tileColors[294][0] = color;
-tileColors[295][0] = color;
-tileColors[296][0] = color;
-tileColors[297][0] = color;
-tileColors[298][0] = color;
-tileColors[299][0] = color;
-tileColors[309][0] = color;
-tileColors[310][0] = color;
-tileColors[413][0] = color;
-tileColors[339][0] = color;
-tileColors[542][0] = color;
-tileColors[632][0] = color;
-tileColors[640][0] = color;
-tileColors[643][0] = color;
-tileColors[644][0] = color;
-tileColors[645][0] = color;
-tileColors[710][0] = color;
-tileColors[358][0] = color;
-tileColors[359][0] = color;
-tileColors[360][0] = color;
-tileColors[361][0] = color;
-tileColors[362][0] = color;
-tileColors[363][0] = color;
-tileColors[364][0] = color;
-tileColors[391][0] = color;
-tileColors[392][0] = color;
-tileColors[393][0] = color;
-tileColors[394][0] = color;
-tileColors[414][0] = color;
-tileColors[505][0] = color;
-tileColors[543][0] = color;
-tileColors[598][0] = color;
-tileColors[521][0] = color;
-tileColors[522][0] = color;
-tileColors[523][0] = color;
-tileColors[524][0] = color;
-tileColors[525][0] = color;
-tileColors[526][0] = color;
-tileColors[527][0] = color;
-tileColors[532][0] = color;
-tileColors[533][0] = color;
-tileColors[538][0] = color;
-tileColors[544][0] = color;
-tileColors[629][0] = color;
-tileColors[550][0] = color;
-tileColors[551][0] = color;
-tileColors[553][0] = color;
-tileColors[554][0] = color;
-tileColors[555][0] = color;
-tileColors[556][0] = color;
-tileColors[558][0] = color;
-tileColors[559][0] = color;
-tileColors[580][0] = color;
-tileColors[582][0] = color;
-tileColors[599][0] = color;
-tileColors[600][0] = color;
-tileColors[601][0] = color;
-tileColors[602][0] = color;
-tileColors[603][0] = color;
-tileColors[604][0] = color;
-tileColors[605][0] = color;
-tileColors[606][0] = color;
-tileColors[607][0] = color;
-tileColors[608][0] = color;
-tileColors[609][0] = color;
-tileColors[610][0] = color;
-tileColors[611][0] = color;
-tileColors[612][0] = color;
-tileColors[619][0] = color;
-tileColors[620][0] = color;
-tileColors[630][0] = rgb(117, 145, 73);
-tileColors[631][0] = rgb(122, 234, 225);
-tileColors[552][0] = tileColors[53][0];
-tileColors[564][0] = rgb(87, 127, 220);
-tileColors[408][0] = rgb(85, 83, 82);
-tileColors[409][0] = rgb(85, 83, 82);
-tileColors[669][0] = rgb(83, 46, 57);
-tileColors[670][0] = rgb(91, 87, 167);
-tileColors[671][0] = rgb(23, 33, 81);
-tileColors[672][0] = rgb(53, 133, 103);
-tileColors[673][0] = rgb(11, 67, 80);
-tileColors[674][0] = rgb(40, 49, 60);
-tileColors[675][0] = rgb(21, 13, 77);
-tileColors[676][0] = rgb(195, 201, 215);
-tileColors[415][0] = rgb(249, 75, 7);
-tileColors[416][0] = rgb(0, 160, 170);
-tileColors[417][0] = rgb(160, 87, 234);
-tileColors[418][0] = rgb(22, 173, 254);
-tileColors[489][0] = rgb(255, 29, 136);
-tileColors[490][0] = rgb(211, 211, 211);
-tileColors[311][0] = rgb(117, 61, 25);
-tileColors[312][0] = rgb(204, 93, 73);
-tileColors[313][0] = rgb(87, 150, 154);
-tileColors[4][0] = rgb(253, 221, 3);
-tileColors[4][1] = rgb(253, 221, 3);
-color = rgb(253, 221, 3);
-tileColors[93][0] = color;
-tileColors[33][0] = color;
-tileColors[174][0] = color;
-tileColors[100][0] = color;
-tileColors[98][0] = color;
-tileColors[173][0] = color;
-color = rgb(119, 105, 79);
-tileColors[11][0] = color;
-tileColors[10][0] = color;
-tileColors[593][0] = color;
-tileColors[594][0] = color;
-color = rgb(191, 142, 111);
-tileColors[14][0] = color;
-tileColors[469][0] = color;
-tileColors[486][0] = color;
-tileColors[488][0] = rgb(127, 92, 69);
-tileColors[704][0] = tileColors[488][0];
-tileColors[487][0] = color;
-tileColors[487][1] = color;
-tileColors[15][0] = color;
-tileColors[15][1] = color;
-tileColors[497][0] = color;
-tileColors[18][0] = color;
-tileColors[19][0] = color;
-tileColors[19][1] = rgb(0, 0, 0);
-tileColors[55][0] = color;
-tileColors[79][0] = color;
-tileColors[86][0] = color;
-tileColors[87][0] = color;
-tileColors[88][0] = color;
-tileColors[89][0] = color;
-tileColors[89][1] = color;
-tileColors[89][2] = rgb(105, 107, 125);
-tileColors[94][0] = color;
-tileColors[101][0] = color;
-tileColors[104][0] = color;
-tileColors[106][0] = color;
-tileColors[114][0] = color;
-tileColors[128][0] = color;
-tileColors[139][0] = color;
-tileColors[172][0] = color;
-tileColors[216][0] = color;
-tileColors[269][0] = color;
-tileColors[334][0] = color;
-tileColors[471][0] = color;
-tileColors[470][0] = color;
-tileColors[475][0] = color;
-tileColors[377][0] = color;
-tileColors[380][0] = color;
-tileColors[395][0] = color;
-tileColors[573][0] = color;
-tileColors[12][0] = rgb(174, 24, 69);
-tileColors[665][0] = rgb(174, 24, 69);
-tileColors[639][0] = rgb(110, 105, 255);
-tileColors[13][0] = rgb(133, 213, 247);
-color = rgb(144, 148, 144);
-tileColors[17][0] = color;
-tileColors[90][0] = color;
-tileColors[96][0] = color;
-tileColors[97][0] = color;
-tileColors[99][0] = color;
-tileColors[132][0] = color;
-tileColors[142][0] = color;
-tileColors[143][0] = color;
-tileColors[144][0] = color;
-tileColors[207][0] = color;
-tileColors[209][0] = color;
-tileColors[212][0] = color;
-tileColors[217][0] = color;
-tileColors[218][0] = color;
-tileColors[219][0] = color;
-tileColors[220][0] = color;
-tileColors[228][0] = color;
-tileColors[300][0] = color;
-tileColors[301][0] = color;
-tileColors[302][0] = color;
-tileColors[303][0] = color;
-tileColors[304][0] = color;
-tileColors[305][0] = color;
-tileColors[306][0] = color;
-tileColors[307][0] = color;
-tileColors[308][0] = color;
-tileColors[567][0] = color;
-tileColors[349][0] = rgb(144, 148, 144);
-tileColors[531][0] = rgb(144, 148, 144);
-tileColors[105][0] = rgb(144, 148, 144);
-tileColors[105][1] = rgb(177, 92, 31);
-tileColors[105][2] = rgb(201, 188, 170);
-tileColors[137][0] = rgb(144, 148, 144);
-tileColors[137][1] = rgb(141, 56, 0);
-tileColors[137][2] = rgb(144, 148, 144);
-tileColors[16][0] = rgb(140, 130, 116);
-tileColors[26][0] = rgb(119, 101, 125);
-tileColors[26][1] = rgb(214, 127, 133);
-tileColors[695][0] = tileColors[26][0];
-tileColors[695][1] = tileColors[26][1];
-tileColors[36][0] = rgb(230, 89, 92);
-tileColors[28][0] = rgb(151, 79, 80);
-tileColors[28][1] = rgb(90, 139, 140);
-tileColors[28][2] = rgb(192, 136, 70);
-tileColors[28][3] = rgb(203, 185, 151);
-tileColors[28][4] = rgb(73, 56, 41);
-tileColors[28][5] = rgb(148, 159, 67);
-tileColors[28][6] = rgb(138, 172, 67);
-tileColors[28][7] = rgb(226, 122, 47);
-tileColors[28][8] = rgb(198, 87, 93);
-for (var m = 0; m < tileColors[653].Length; m++)
-{
-  tileColors[653][m] = tileColors[28][m];
-}
-tileColors[29][0] = rgb(175, 105, 128);
-tileColors[51][0] = rgb(192, 202, 203);
-tileColors[697][0] = tileColors[51][0];
-tileColors[698][0] = rgb(200, 200, 200);
-tileColors[31][0] = rgb(141, 120, 168);
-tileColors[31][1] = rgb(212, 105, 105);
-tileColors[696][0] = tileColors[31][0];
-tileColors[696][1] = tileColors[31][1];
-tileColors[32][0] = rgb(151, 135, 183);
-tileColors[42][0] = rgb(251, 235, 127);
-tileColors[50][0] = rgb(170, 48, 114);
-tileColors[707][0] = tileColors[50][0];
-tileColors[85][0] = rgb(192, 192, 192);
-tileColors[69][0] = rgb(190, 150, 92);
-tileColors[77][0] = rgb(238, 85, 70);
-tileColors[81][0] = rgb(245, 133, 191);
-tileColors[78][0] = rgb(121, 110, 97);
-tileColors[141][0] = rgb(192, 59, 59);
-tileColors[129][0] = rgb(255, 117, 224);
-tileColors[129][1] = rgb(255, 117, 224);
-tileColors[126][0] = rgb(159, 209, 229);
-tileColors[125][0] = rgb(141, 175, 255);
-tileColors[103][0] = rgb(141, 98, 77);
-tileColors[95][0] = rgb(255, 162, 31);
-tileColors[92][0] = rgb(213, 229, 237);
-tileColors[91][0] = rgb(13, 88, 130);
-tileColors[215][0] = rgb(254, 121, 2);
-tileColors[592][0] = rgb(254, 121, 2);
-tileColors[316][0] = rgb(157, 176, 226);
-tileColors[317][0] = rgb(118, 227, 129);
-tileColors[318][0] = rgb(227, 118, 215);
-tileColors[319][0] = rgb(96, 68, 48);
-tileColors[320][0] = rgb(203, 185, 151);
-tileColors[321][0] = rgb(96, 77, 64);
-tileColors[574][0] = rgb(76, 57, 44);
-tileColors[322][0] = rgb(198, 170, 104);
-tileColors[635][0] = rgb(145, 120, 120);
-tileColors[149][0] = rgb(220, 50, 50);
-tileColors[149][1] = rgb(0, 220, 50);
-tileColors[149][2] = rgb(50, 50, 220);
-tileColors[133][0] = rgb(231, 53, 56);
-tileColors[133][1] = rgb(192, 189, 221);
-tileColors[134][0] = rgb(166, 187, 153);
-tileColors[134][1] = rgb(241, 129, 249);
-tileColors[102][0] = rgb(229, 212, 73);
-tileColors[35][0] = rgb(226, 145, 30);
-tileColors[34][0] = rgb(235, 166, 135);
-tileColors[136][0] = rgb(213, 203, 204);
-tileColors[231][0] = rgb(224, 194, 101);
-tileColors[239][0] = rgb(224, 194, 101);
-tileColors[240][0] = rgb(120, 85, 60);
-tileColors[240][1] = rgb(99, 50, 30);
-tileColors[240][2] = rgb(153, 153, 117);
-tileColors[240][3] = rgb(112, 84, 56);
-tileColors[240][4] = rgb(234, 231, 226);
-tileColors[241][0] = rgb(77, 74, 72);
-tileColors[244][0] = rgb(200, 245, 253);
-color = rgb(99, 50, 30);
-tileColors[242][0] = color;
-tileColors[245][0] = color;
-tileColors[246][0] = color;
-tileColors[242][1] = rgb(185, 142, 97);
-tileColors[247][0] = rgb(140, 150, 150);
-tileColors[271][0] = rgb(107, 250, 255);
-tileColors[270][0] = rgb(187, 255, 107);
-tileColors[581][0] = rgb(255, 150, 150);
-tileColors[660][0] = rgb(255, 150, 150);
-tileColors[572][0] = rgb(255, 186, 212);
-tileColors[572][1] = rgb(209, 201, 255);
-tileColors[572][2] = rgb(200, 254, 255);
-tileColors[572][3] = rgb(199, 255, 211);
-tileColors[572][4] = rgb(180, 209, 255);
-tileColors[572][5] = rgb(255, 220, 214);
-tileColors[314][0] = rgb(181, 164, 125);
-tileColors[324][0] = rgb(228, 213, 173);
-tileColors[351][0] = rgb(31, 31, 31);
-tileColors[424][0] = rgb(146, 155, 187);
-tileColors[429][0] = rgb(220, 220, 220);
-tileColors[445][0] = rgb(240, 240, 240);
-tileColors[21][0] = rgb(174, 129, 92);
-tileColors[21][1] = rgb(233, 207, 94);
-tileColors[21][2] = rgb(137, 128, 200);
-tileColors[21][3] = rgb(160, 160, 160);
-tileColors[21][4] = rgb(106, 210, 255);
-tileColors[441][0] = tileColors[21][0];
-tileColors[441][1] = tileColors[21][1];
-tileColors[441][2] = tileColors[21][2];
-tileColors[441][3] = tileColors[21][3];
-tileColors[441][4] = tileColors[21][4];
-tileColors[27][0] = rgb(54, 154, 54);
-tileColors[27][1] = rgb(226, 196, 49);
-color = rgb(246, 197, 26);
-tileColors[82][0] = color;
-tileColors[83][0] = color;
-tileColors[84][0] = color;
-color = rgb(76, 150, 216);
-tileColors[82][1] = color;
-tileColors[83][1] = color;
-tileColors[84][1] = color;
-color = rgb(185, 214, 42);
-tileColors[82][2] = color;
-tileColors[83][2] = color;
-tileColors[84][2] = color;
-color = rgb(167, 203, 37);
-tileColors[82][3] = color;
-tileColors[83][3] = color;
-tileColors[84][3] = color;
-tileColors[591][6] = color;
-color = rgb(32, 168, 117);
-tileColors[82][4] = color;
-tileColors[83][4] = color;
-tileColors[84][4] = color;
-color = rgb(177, 69, 49);
-tileColors[82][5] = color;
-tileColors[83][5] = color;
-tileColors[84][5] = color;
-color = rgb(40, 152, 240);
-tileColors[82][6] = color;
-tileColors[83][6] = color;
-tileColors[84][6] = color;
-tileColors[591][1] = rgb(246, 197, 26);
-tileColors[591][2] = rgb(76, 150, 216);
-tileColors[591][3] = rgb(32, 168, 117);
-tileColors[591][4] = rgb(40, 152, 240);
-tileColors[591][5] = rgb(114, 81, 56);
-tileColors[591][6] = rgb(141, 137, 223);
-tileColors[591][7] = rgb(208, 80, 80);
-tileColors[591][8] = rgb(177, 69, 49);
-tileColors[165][0] = rgb(115, 173, 229);
-tileColors[165][1] = rgb(100, 100, 100);
-tileColors[165][2] = rgb(152, 152, 152);
-tileColors[165][3] = rgb(227, 125, 22);
-for (var n = 0; n < tileColors[693].Length; n++)
-{
-  tileColors[693][n] = tileColors[165][n];
-  tileColors[694][n] = tileColors[165][n];
-}
-tileColors[178][0] = rgb(208, 94, 201);
-tileColors[178][1] = rgb(233, 146, 69);
-tileColors[178][2] = rgb(71, 146, 251);
-tileColors[178][3] = rgb(60, 226, 133);
-tileColors[178][4] = rgb(250, 30, 71);
-tileColors[178][5] = rgb(166, 176, 204);
-tileColors[178][6] = rgb(255, 217, 120);
-color = rgb(99, 99, 99);
-tileColors[185][0] = color;
-tileColors[186][0] = color;
-tileColors[187][0] = color;
-tileColors[565][0] = color;
-tileColors[579][0] = color;
-color = rgb(114, 81, 56);
-tileColors[185][1] = color;
-tileColors[186][1] = color;
-tileColors[187][1] = color;
-tileColors[591][0] = color;
-color = rgb(133, 133, 101);
-tileColors[185][2] = color;
-tileColors[186][2] = color;
-tileColors[187][2] = color;
-color = rgb(151, 200, 211);
-tileColors[185][3] = color;
-tileColors[186][3] = color;
-tileColors[187][3] = color;
-color = rgb(177, 183, 161);
-tileColors[185][4] = color;
-tileColors[186][4] = color;
-tileColors[187][4] = color;
-color = rgb(134, 114, 38);
-tileColors[185][5] = color;
-tileColors[186][5] = color;
-tileColors[187][5] = color;
-color = rgb(82, 62, 66);
-tileColors[185][6] = color;
-tileColors[186][6] = color;
-tileColors[187][6] = color;
-color = rgb(143, 117, 121);
-tileColors[185][7] = color;
-tileColors[186][7] = color;
-tileColors[187][7] = color;
-color = rgb(177, 92, 31);
-tileColors[185][8] = color;
-tileColors[186][8] = color;
-tileColors[187][8] = color;
-color = rgb(85, 73, 87);
-tileColors[185][9] = color;
-tileColors[186][9] = color;
-tileColors[187][9] = color;
-color = rgb(26, 196, 84);
-tileColors[185][10] = color;
-tileColors[186][10] = color;
-tileColors[187][10] = color;
-color = tileColors[53][0];
-tileColors[185][11] = color;
-tileColors[186][11] = color;
-tileColors[187][11] = color;
-tileColors[227][0] = rgb(74, 197, 155);
-tileColors[227][1] = rgb(54, 153, 88);
-tileColors[227][2] = rgb(63, 126, 207);
-tileColors[227][3] = rgb(240, 180, 4);
-tileColors[227][4] = rgb(45, 68, 168);
-tileColors[227][5] = rgb(61, 92, 0);
-tileColors[227][6] = rgb(216, 112, 152);
-tileColors[227][7] = rgb(200, 40, 24);
-tileColors[227][8] = rgb(113, 45, 133);
-tileColors[227][9] = rgb(235, 137, 2);
-tileColors[227][10] = rgb(41, 152, 135);
-tileColors[227][11] = rgb(198, 19, 78);
-tileColors[373][0] = rgb(9, 61, 191);
-tileColors[374][0] = rgb(253, 32, 3);
-tileColors[375][0] = rgb(255, 156, 12);
-tileColors[461][0] = rgb(212, 192, 100);
-tileColors[461][1] = rgb(137, 132, 156);
-tileColors[461][2] = rgb(148, 122, 112);
-tileColors[461][3] = rgb(221, 201, 206);
-tileColors[323][0] = rgb(182, 141, 86);
-tileColors[325][0] = rgb(129, 125, 93);
-tileColors[326][0] = rgb(9, 61, 191);
-tileColors[327][0] = rgb(253, 32, 3);
-tileColors[507][0] = rgb(5, 5, 5);
-tileColors[508][0] = rgb(5, 5, 5);
-tileColors[330][0] = rgb(226, 118, 76);
-tileColors[331][0] = rgb(161, 172, 173);
-tileColors[332][0] = rgb(204, 181, 72);
-tileColors[333][0] = rgb(190, 190, 178);
-tileColors[335][0] = rgb(217, 174, 137);
-tileColors[336][0] = rgb(253, 62, 3);
-tileColors[337][0] = rgb(144, 148, 144);
-tileColors[338][0] = rgb(85, 255, 160);
-tileColors[315][0] = rgb(235, 114, 80);
-tileColors[641][0] = rgb(235, 125, 150);
-tileColors[340][0] = rgb(96, 248, 2);
-tileColors[341][0] = rgb(105, 74, 202);
-tileColors[342][0] = rgb(29, 240, 255);
-tileColors[343][0] = rgb(254, 202, 80);
-tileColors[344][0] = rgb(131, 252, 245);
-tileColors[345][0] = rgb(255, 156, 12);
-tileColors[346][0] = rgb(149, 212, 89);
-tileColors[642][0] = rgb(149, 212, 89);
-tileColors[347][0] = rgb(236, 74, 79);
-tileColors[348][0] = rgb(44, 26, 233);
-tileColors[350][0] = rgb(55, 97, 155);
-tileColors[352][0] = rgb(238, 97, 94);
-tileColors[354][0] = rgb(141, 107, 89);
-tileColors[355][0] = rgb(141, 107, 89);
-tileColors[699][0] = rgb(141, 107, 89);
-tileColors[463][0] = rgb(155, 214, 240);
-tileColors[491][0] = rgb(60, 20, 160);
-tileColors[464][0] = rgb(233, 183, 128);
-tileColors[465][0] = rgb(51, 84, 195);
-tileColors[466][0] = rgb(205, 153, 73);
-tileColors[356][0] = rgb(233, 203, 24);
-tileColors[663][0] = rgb(24, 203, 233);
-tileColors[357][0] = rgb(168, 178, 204);
-tileColors[367][0] = rgb(168, 178, 204);
-tileColors[561][0] = rgb(148, 158, 184);
-tileColors[365][0] = rgb(146, 136, 205);
-tileColors[366][0] = rgb(223, 232, 233);
-tileColors[368][0] = rgb(50, 46, 104);
-tileColors[369][0] = rgb(50, 46, 104);
-tileColors[576][0] = rgb(30, 26, 84);
-tileColors[370][0] = rgb(127, 116, 194);
-tileColors[49][0] = rgb(89, 201, 255);
-tileColors[372][0] = rgb(252, 128, 201);
-tileColors[646][0] = rgb(108, 133, 140);
-tileColors[371][0] = rgb(249, 101, 189);
-tileColors[376][0] = rgb(160, 120, 92);
-tileColors[378][0] = rgb(160, 120, 100);
-tileColors[379][0] = rgb(251, 209, 240);
-tileColors[382][0] = rgb(28, 216, 94);
-tileColors[383][0] = rgb(221, 136, 144);
-tileColors[384][0] = rgb(131, 206, 12);
-tileColors[385][0] = rgb(87, 21, 144);
-tileColors[386][0] = rgb(127, 92, 69);
-tileColors[387][0] = rgb(127, 92, 69);
-tileColors[388][0] = rgb(127, 92, 69);
-tileColors[389][0] = rgb(127, 92, 69);
-tileColors[390][0] = rgb(253, 32, 3);
-tileColors[397][0] = rgb(212, 192, 100);
-tileColors[396][0] = rgb(198, 124, 78);
-tileColors[577][0] = rgb(178, 104, 58);
-tileColors[398][0] = rgb(100, 82, 126);
-tileColors[399][0] = rgb(77, 76, 66);
-tileColors[400][0] = rgb(96, 68, 117);
-tileColors[401][0] = rgb(68, 60, 51);
-tileColors[402][0] = rgb(174, 168, 186);
-tileColors[403][0] = rgb(205, 152, 186);
-tileColors[404][0] = rgb(212, 148, 88);
-tileColors[405][0] = rgb(140, 140, 140);
-tileColors[406][0] = rgb(120, 120, 120);
-tileColors[407][0] = rgb(255, 227, 132);
-tileColors[411][0] = rgb(227, 46, 46);
-tileColors[494][0] = rgb(227, 227, 227);
-tileColors[421][0] = rgb(65, 75, 90);
-tileColors[422][0] = rgb(65, 75, 90);
-tileColors[425][0] = rgb(146, 155, 187);
-tileColors[426][0] = rgb(168, 38, 47);
-tileColors[430][0] = rgb(39, 168, 96);
-tileColors[431][0] = rgb(39, 94, 168);
-tileColors[432][0] = rgb(242, 221, 100);
-tileColors[433][0] = rgb(224, 100, 242);
-tileColors[434][0] = rgb(197, 193, 216);
-tileColors[727][0] = rgb(119, 22, 52);
-tileColors[728][0] = rgb(23, 119, 79);
-tileColors[729][0] = rgb(23, 54, 119);
-tileColors[730][0] = rgb(119, 68, 23);
-tileColors[731][0] = rgb(74, 23, 119);
-tileColors[732][0] = rgb(78, 82, 109);
-tileColors[427][0] = rgb(183, 53, 62);
-tileColors[435][0] = rgb(54, 183, 111);
-tileColors[436][0] = rgb(54, 109, 183);
-tileColors[437][0] = rgb(255, 236, 115);
-tileColors[438][0] = rgb(239, 115, 255);
-tileColors[439][0] = rgb(212, 208, 231);
-tileColors[440][0] = rgb(238, 51, 53);
-tileColors[440][1] = rgb(13, 107, 216);
-tileColors[440][2] = rgb(33, 184, 115);
-tileColors[440][3] = rgb(255, 221, 62);
-tileColors[440][4] = rgb(165, 0, 236);
-tileColors[440][5] = rgb(223, 230, 238);
-tileColors[440][6] = rgb(207, 101, 0);
-tileColors[419][0] = rgb(88, 95, 114);
-tileColors[419][1] = rgb(214, 225, 236);
-tileColors[419][2] = rgb(25, 131, 205);
-tileColors[423][0] = rgb(245, 197, 1);
-tileColors[423][1] = rgb(185, 0, 224);
-tileColors[423][2] = rgb(58, 240, 111);
-tileColors[423][3] = rgb(50, 107, 197);
-tileColors[423][4] = rgb(253, 91, 3);
-tileColors[423][5] = rgb(254, 194, 20);
-tileColors[423][6] = rgb(174, 195, 215);
-tileColors[420][0] = rgb(99, 255, 107);
-tileColors[420][1] = rgb(99, 255, 107);
-tileColors[420][4] = rgb(99, 255, 107);
-tileColors[420][2] = rgb(218, 2, 5);
-tileColors[420][3] = rgb(218, 2, 5);
-tileColors[420][5] = rgb(218, 2, 5);
-tileColors[476][0] = rgb(160, 160, 160);
-tileColors[410][0] = rgb(75, 139, 166);
-tileColors[480][0] = rgb(120, 50, 50);
-tileColors[509][0] = rgb(50, 50, 60);
-tileColors[657][0] = rgb(35, 205, 215);
-tileColors[658][0] = rgb(200, 105, 230);
-tileColors[412][0] = rgb(75, 139, 166);
-tileColors[720][0] = rgb(164, 175, 175);
-tileColors[721][0] = rgb(77, 176, 144);
-tileColors[725][0] = rgb(229, 65, 65);
-tileColors[733][0] = rgb(115, 69, 27);
-tileColors[751][0] = rgb(128, 128, 128);
-tileColors[752][0] = rgb(128, 128, 128);
-tileColors[443][0] = rgb(144, 148, 144);
-tileColors[442][0] = rgb(3, 144, 201);
-tileColors[444][0] = rgb(191, 176, 124);
-tileColors[446][0] = rgb(255, 66, 152);
-tileColors[447][0] = rgb(179, 132, 255);
-tileColors[448][0] = rgb(0, 206, 180);
-tileColors[449][0] = rgb(91, 186, 240);
-tileColors[450][0] = rgb(92, 240, 91);
-tileColors[451][0] = rgb(240, 91, 147);
-tileColors[452][0] = rgb(255, 150, 181);
-tileColors[453][0] = rgb(179, 132, 255);
-tileColors[453][1] = rgb(0, 206, 180);
-tileColors[453][2] = rgb(255, 66, 152);
-tileColors[454][0] = rgb(174, 16, 176);
-tileColors[455][0] = rgb(48, 225, 110);
-tileColors[456][0] = rgb(179, 132, 255);
-tileColors[457][0] = rgb(150, 164, 206);
-tileColors[457][1] = rgb(255, 132, 184);
-tileColors[457][2] = rgb(74, 255, 232);
-tileColors[457][3] = rgb(215, 159, 255);
-tileColors[457][4] = rgb(229, 219, 234);
-tileColors[458][0] = rgb(211, 198, 111);
-tileColors[459][0] = rgb(190, 223, 232);
-tileColors[460][0] = rgb(141, 163, 181);
-tileColors[717][0] = rgb(126, 102, 118);
-tileColors[718][0] = rgb(245, 215, 196);
-tileColors[719][0] = rgb(223, 255, 255);
-tileColors[462][0] = rgb(231, 178, 28);
-tileColors[467][0] = rgb(129, 56, 121);
-tileColors[467][1] = rgb(255, 249, 59);
-tileColors[467][2] = rgb(161, 67, 24);
-tileColors[467][3] = rgb(89, 70, 72);
-tileColors[467][4] = rgb(233, 207, 94);
-tileColors[467][5] = rgb(254, 158, 35);
-tileColors[467][6] = rgb(34, 221, 151);
-tileColors[467][7] = rgb(249, 170, 236);
-tileColors[467][8] = rgb(35, 200, 254);
-tileColors[467][9] = rgb(190, 200, 200);
-tileColors[467][10] = rgb(230, 170, 100);
-tileColors[467][11] = rgb(165, 168, 26);
-tileColors[467][12] = tileColors[21][0];
-for (var num5 = 0; num5 < 13; num5++)
-{
-  tileColors[468][num5] = tileColors[467][num5];
-}
-tileColors[472][0] = rgb(190, 160, 140);
-tileColors[726][0] = rgb(30, 30, 36);
-tileColors[473][0] = rgb(85, 114, 123);
-tileColors[474][0] = rgb(116, 94, 97);
-tileColors[478][0] = rgb(108, 34, 35);
-tileColors[479][0] = rgb(178, 114, 68);
-tileColors[485][0] = rgb(198, 134, 88);
-tileColors[492][0] = rgb(78, 193, 227);
-tileColors[492][0] = rgb(78, 193, 227);
-tileColors[493][0] = rgb(250, 249, 252);
-tileColors[493][1] = rgb(240, 90, 90);
-tileColors[493][2] = rgb(98, 230, 92);
-tileColors[493][3] = rgb(95, 197, 238);
-tileColors[493][4] = rgb(241, 221, 100);
-tileColors[493][5] = rgb(213, 92, 237);
-tileColors[494][0] = rgb(224, 219, 236);
-tileColors[495][0] = rgb(253, 227, 215);
-tileColors[496][0] = rgb(165, 159, 153);
-tileColors[498][0] = rgb(202, 174, 165);
-tileColors[499][0] = rgb(160, 187, 142);
-tileColors[500][0] = rgb(254, 158, 35);
-tileColors[501][0] = rgb(34, 221, 151);
-tileColors[502][0] = rgb(249, 170, 236);
-tileColors[503][0] = rgb(35, 200, 254);
-tileColors[506][0] = rgb(61, 61, 61);
-tileColors[510][0] = rgb(191, 142, 111);
-tileColors[511][0] = rgb(187, 68, 74);
-tileColors[520][0] = rgb(224, 219, 236);
-tileColors[545][0] = rgb(255, 126, 145);
-tileColors[530][0] = rgb(107, 182, 0);
-tileColors[530][1] = rgb(23, 154, 209);
-tileColors[530][2] = rgb(238, 97, 94);
-tileColors[530][3] = rgb(113, 108, 205);
-tileColors[705][0] = tileColors[530][0];
-tileColors[705][1] = tileColors[530][1];
-tileColors[705][2] = tileColors[530][2];
-tileColors[705][3] = tileColors[530][3];
-tileColors[546][0] = rgb(60, 60, 60);
-tileColors[557][0] = rgb(60, 60, 60);
-tileColors[547][0] = rgb(120, 110, 100);
-tileColors[548][0] = rgb(120, 110, 100);
-tileColors[562][0] = rgb(165, 168, 26);
-tileColors[563][0] = rgb(165, 168, 26);
-tileColors[571][0] = rgb(165, 168, 26);
-tileColors[568][0] = rgb(248, 203, 233);
-tileColors[569][0] = rgb(203, 248, 218);
-tileColors[570][0] = rgb(160, 242, 255);
-tileColors[597][0] = rgb(28, 216, 94);
-tileColors[597][1] = rgb(183, 237, 20);
-tileColors[597][2] = rgb(185, 83, 200);
-tileColors[597][3] = rgb(131, 128, 168);
-tileColors[597][4] = rgb(38, 142, 214);
-tileColors[597][5] = rgb(229, 154, 9);
-tileColors[597][6] = rgb(142, 227, 234);
-tileColors[597][7] = rgb(98, 111, 223);
-tileColors[597][8] = rgb(241, 233, 158);
-tileColors[597][9] = rgb(238, 85, 70);
-tileColors[597][10] = rgb(247, 228, 254);
-tileColors[617][0] = rgb(233, 207, 94);
-var color3 = rgb(250, 100, 50);
-tileColors[548][1] = color3;
-tileColors[613][0] = color3;
-tileColors[614][0] = color3;
-tileColors[623][0] = rgb(220, 210, 245);
-tileColors[661][0] = rgb(141, 137, 223);
-tileColors[662][0] = rgb(208, 80, 80);
-tileColors[666][0] = rgb(115, 60, 40);
-tileColors[667][0] = rgb(247, 228, 254);
-tileColors[708][0] = rgb(237, 218, 244);
-tileColors[709][0] = rgb(247, 228, 254);
-tileColors[722][0] = rgb(185, 190, 20);
-tileColors[723][0] = rgb(185, 190, 20);
-tileColors[724][0] = rgb(185, 190, 20);
-tileColors[734][0] = rgb(160, 115, 80);
-tileColors[735][0] = rgb(235, 200, 20);
-tileColors[736][0] = rgb(240, 130, 160);
-tileColors[737][0] = rgb(65, 75, 65);
-tileColors[738][0] = rgb(210, 170, 215);
-tileColors[739][0] = rgb(90, 125, 235);
-tileColors[740][0] = rgb(211, 211, 211);
-tileColors[741][0] = rgb(160, 90, 50);
-tileColors[742][0] = rgb(26, 141, 204);
-tileColors[743][0] = rgb(227, 227, 227);
-tileColors[744][0] = rgb(106, 103, 96);
-tileColors[745][0] = rgb(120, 114, 108);
-tileColors[746][0] = rgb(122, 78, 21);
-tileColors[747][0] = rgb(231, 178, 28);
-tileColors[748][0] = rgb(2, 114, 206);
-tileColors[749][0] = tileColors[138][0] * 0.95;
-tileColors[750][0] = tileColors[48][0] * 0.95;
-
-liquidColors[0] = rgb(9, 61, 191);
-liquidColors[1] = rgb(253, 32, 3);
-liquidColors[2] = rgb(254, 194, 20);
-liquidColors[3] = rgb(161, 127, 255);
-
-for (var j = 0; j < wallColors.length; j++) {
-  wallColors[j] = new Array(2);
-}
-
-wallColors[158][0] = rgb(107, 49, 154);
-wallColors[163][0] = rgb(154, 148, 49);
-wallColors[162][0] = rgb(49, 49, 154);
-wallColors[160][0] = rgb(49, 154, 68);
-wallColors[161][0] = rgb(154, 49, 77);
-wallColors[159][0] = rgb(85, 89, 118);
-wallColors[157][0] = rgb(154, 83, 49);
-wallColors[154][0] = rgb(221, 79, 255);
-wallColors[166][0] = rgb(250, 255, 79);
-wallColors[165][0] = rgb(79, 102, 255);
-wallColors[156][0] = rgb(79, 255, 89);
-wallColors[164][0] = rgb(255, 79, 79);
-wallColors[155][0] = rgb(240, 240, 247);
-wallColors[153][0] = rgb(255, 145, 79);
-wallColors[169][0] = rgb(5, 5, 5);
-wallColors[224][0] = rgb(57, 55, 52);
-wallColors[323][0] = rgb(55, 25, 33);
-wallColors[324][0] = rgb(60, 55, 145);
-wallColors[325][0] = rgb(10, 5, 50);
-wallColors[326][0] = rgb(30, 105, 75);
-wallColors[327][0] = rgb(5, 45, 55);
-wallColors[328][0] = rgb(20, 25, 35);
-wallColors[329][0] = rgb(15, 10, 50);
-wallColors[330][0] = rgb(153, 164, 187);
-wallColors[225][0] = rgb(68, 68, 68);
-wallColors[226][0] = rgb(148, 138, 74);
-wallColors[227][0] = rgb(95, 137, 191);
-wallColors[170][0] = rgb(59, 39, 22);
-wallColors[171][0] = rgb(59, 39, 22);
-color = rgb(52, 52, 52);
-wallColors[1][0] = color;
-wallColors[53][0] = color;
-wallColors[52][0] = color;
-wallColors[51][0] = color;
-wallColors[50][0] = color;
-wallColors[49][0] = color;
-wallColors[48][0] = color;
-wallColors[44][0] = color;
-wallColors[346][0] = color;
-wallColors[5][0] = color;
-wallColors[349][0] = color;
-wallColors[350][0] = rgb(0, 255, 0);
-color = rgb(88, 61, 46);
-wallColors[2][0] = color;
-wallColors[16][0] = color;
-wallColors[59][0] = color;
-wallColors[3][0] = rgb(61, 58, 78);
-wallColors[4][0] = rgb(73, 51, 36);
-wallColors[6][0] = rgb(91, 30, 30);
-color = rgb(27, 31, 42);
-wallColors[7][0] = color;
-wallColors[17][0] = color;
-wallColors[331][0] = color;
-color = rgb(32, 40, 45);
-wallColors[94][0] = color;
-wallColors[100][0] = color;
-color = rgb(44, 41, 50);
-wallColors[95][0] = color;
-wallColors[101][0] = color;
-color = rgb(31, 39, 26);
-wallColors[8][0] = color;
-wallColors[18][0] = color;
-wallColors[332][0] = color;
-color = rgb(36, 45, 44);
-wallColors[98][0] = color;
-wallColors[104][0] = color;
-color = rgb(38, 49, 50);
-wallColors[99][0] = color;
-wallColors[105][0] = color;
-color = rgb(41, 28, 36);
-wallColors[9][0] = color;
-wallColors[19][0] = color;
-wallColors[333][0] = color;
-color = rgb(72, 50, 77);
-wallColors[96][0] = color;
-wallColors[102][0] = color;
-color = rgb(78, 50, 69);
-wallColors[97][0] = color;
-wallColors[103][0] = color;
-wallColors[10][0] = rgb(74, 62, 12);
-wallColors[334][0] = rgb(74, 62, 12);
-wallColors[11][0] = rgb(46, 56, 59);
-wallColors[335][0] = rgb(46, 56, 59);
-wallColors[12][0] = rgb(75, 32, 11);
-wallColors[336][0] = rgb(75, 32, 11);
-wallColors[13][0] = rgb(67, 37, 37);
-wallColors[338][0] = rgb(67, 37, 37);
-color = rgb(15, 15, 15);
-wallColors[14][0] = color;
-wallColors[337][0] = color;
-wallColors[20][0] = color;
-wallColors[15][0] = rgb(52, 43, 45);
-wallColors[22][0] = rgb(113, 99, 99);
-wallColors[23][0] = rgb(38, 38, 43);
-wallColors[24][0] = rgb(53, 39, 41);
-wallColors[25][0] = rgb(11, 35, 62);
-wallColors[339][0] = rgb(11, 35, 62);
-wallColors[26][0] = rgb(21, 63, 70);
-wallColors[340][0] = rgb(21, 63, 70);
-wallColors[27][0] = rgb(88, 61, 46);
-wallColors[27][1] = rgb(52, 52, 52);
-wallColors[28][0] = rgb(81, 84, 101);
-wallColors[29][0] = rgb(88, 23, 23);
-wallColors[30][0] = rgb(28, 88, 23);
-wallColors[31][0] = rgb(78, 87, 99);
-color = rgb(69, 67, 41);
-wallColors[34][0] = color;
-wallColors[37][0] = color;
-wallColors[32][0] = rgb(86, 17, 40);
-wallColors[33][0] = rgb(49, 47, 83);
-wallColors[35][0] = rgb(51, 51, 70);
-wallColors[36][0] = rgb(87, 59, 55);
-wallColors[38][0] = rgb(49, 57, 49);
-wallColors[39][0] = rgb(78, 79, 73);
-wallColors[45][0] = rgb(60, 59, 51);
-wallColors[46][0] = rgb(48, 57, 47);
-wallColors[47][0] = rgb(71, 77, 85);
-wallColors[40][0] = rgb(85, 102, 103);
-wallColors[41][0] = rgb(52, 50, 62);
-wallColors[42][0] = rgb(71, 42, 44);
-wallColors[43][0] = rgb(73, 66, 50);
-wallColors[54][0] = rgb(40, 56, 50);
-wallColors[55][0] = rgb(49, 48, 36);
-wallColors[56][0] = rgb(43, 33, 32);
-wallColors[57][0] = rgb(31, 40, 49);
-wallColors[58][0] = rgb(48, 35, 52);
-wallColors[60][0] = rgb(1, 52, 20);
-wallColors[61][0] = rgb(55, 39, 26);
-wallColors[62][0] = rgb(39, 33, 26);
-wallColors[69][0] = rgb(43, 42, 68);
-wallColors[70][0] = rgb(30, 70, 80);
-wallColors[341][0] = rgb(100, 40, 1);
-wallColors[342][0] = rgb(92, 30, 72);
-wallColors[343][0] = rgb(42, 81, 1);
-wallColors[344][0] = rgb(1, 81, 109);
-wallColors[345][0] = rgb(56, 22, 97);
-color = rgb(30, 80, 48);
-wallColors[63][0] = color;
-wallColors[65][0] = color;
-wallColors[66][0] = color;
-wallColors[68][0] = color;
-color = rgb(53, 80, 30);
-wallColors[64][0] = color;
-wallColors[67][0] = color;
-wallColors[78][0] = rgb(63, 39, 26);
-wallColors[244][0] = rgb(63, 39, 26);
-wallColors[71][0] = rgb(78, 105, 135);
-wallColors[72][0] = rgb(52, 84, 12);
-wallColors[73][0] = rgb(190, 204, 223);
-color = rgb(64, 62, 80);
-wallColors[74][0] = color;
-wallColors[80][0] = color;
-wallColors[75][0] = rgb(65, 65, 35);
-wallColors[76][0] = rgb(20, 46, 104);
-wallColors[77][0] = rgb(61, 13, 16);
-wallColors[79][0] = rgb(51, 47, 96);
-wallColors[81][0] = rgb(101, 51, 51);
-wallColors[82][0] = rgb(77, 64, 34);
-wallColors[83][0] = rgb(62, 38, 41);
-wallColors[234][0] = rgb(60, 36, 39);
-wallColors[84][0] = rgb(48, 78, 93);
-wallColors[85][0] = rgb(54, 63, 69);
-color = rgb(138, 73, 38);
-wallColors[86][0] = color;
-wallColors[108][0] = color;
-color = rgb(50, 15, 8);
-wallColors[87][0] = color;
-wallColors[112][0] = color;
-wallColors[109][0] = rgb(94, 25, 17);
-wallColors[110][0] = rgb(125, 36, 122);
-wallColors[111][0] = rgb(51, 35, 27);
-wallColors[113][0] = rgb(135, 58, 0);
-wallColors[114][0] = rgb(65, 52, 15);
-wallColors[115][0] = rgb(39, 42, 51);
-wallColors[116][0] = rgb(89, 26, 27);
-wallColors[117][0] = rgb(126, 123, 115);
-wallColors[118][0] = rgb(8, 50, 19);
-wallColors[119][0] = rgb(95, 21, 24);
-wallColors[120][0] = rgb(17, 31, 65);
-wallColors[121][0] = rgb(192, 173, 143);
-wallColors[122][0] = rgb(114, 114, 131);
-wallColors[123][0] = rgb(136, 119, 7);
-wallColors[124][0] = rgb(8, 72, 3);
-wallColors[125][0] = rgb(117, 132, 82);
-wallColors[126][0] = rgb(100, 102, 114);
-wallColors[127][0] = rgb(30, 118, 226);
-wallColors[128][0] = rgb(93, 6, 102);
-wallColors[129][0] = rgb(64, 40, 169);
-wallColors[130][0] = rgb(39, 34, 180);
-wallColors[131][0] = rgb(87, 94, 125);
-wallColors[132][0] = rgb(6, 6, 6);
-wallColors[133][0] = rgb(69, 72, 186);
-wallColors[134][0] = rgb(130, 62, 16);
-wallColors[135][0] = rgb(22, 123, 163);
-wallColors[136][0] = rgb(40, 86, 151);
-wallColors[137][0] = rgb(183, 75, 15);
-wallColors[138][0] = rgb(83, 80, 100);
-wallColors[139][0] = rgb(115, 65, 68);
-wallColors[140][0] = rgb(119, 108, 81);
-wallColors[141][0] = rgb(59, 67, 71);
-wallColors[142][0] = rgb(222, 216, 202);
-wallColors[143][0] = rgb(90, 112, 105);
-wallColors[144][0] = rgb(62, 28, 87);
-wallColors[146][0] = rgb(120, 59, 19);
-wallColors[147][0] = rgb(59, 59, 59);
-wallColors[148][0] = rgb(229, 218, 161);
-wallColors[149][0] = rgb(73, 59, 50);
-wallColors[151][0] = rgb(102, 75, 34);
-wallColors[167][0] = rgb(70, 68, 51);
-var color4 = rgb(125, 100, 100);
-wallColors[316][0] = color4;
-wallColors[317][0] = color4;
-wallColors[172][0] = rgb(163, 96, 0);
-wallColors[242][0] = rgb(5, 5, 5);
-wallColors[243][0] = rgb(5, 5, 5);
-wallColors[173][0] = rgb(94, 163, 46);
-wallColors[174][0] = rgb(117, 32, 59);
-wallColors[175][0] = rgb(20, 11, 203);
-wallColors[176][0] = rgb(74, 69, 88);
-wallColors[177][0] = rgb(60, 30, 30);
-wallColors[183][0] = rgb(111, 117, 135);
-wallColors[179][0] = rgb(111, 117, 135);
-wallColors[178][0] = rgb(111, 117, 135);
-wallColors[184][0] = rgb(25, 23, 54);
-wallColors[181][0] = rgb(25, 23, 54);
-wallColors[180][0] = rgb(25, 23, 54);
-wallColors[182][0] = rgb(74, 71, 129);
-wallColors[185][0] = rgb(52, 52, 52);
-wallColors[186][0] = rgb(38, 9, 66);
-wallColors[216][0] = rgb(158, 100, 64);
-wallColors[217][0] = rgb(62, 45, 75);
-wallColors[218][0] = rgb(57, 14, 12);
-wallColors[219][0] = rgb(96, 72, 133);
-wallColors[187][0] = rgb(149, 80, 51);
-wallColors[235][0] = rgb(140, 75, 48);
-wallColors[220][0] = rgb(67, 55, 80);
-wallColors[221][0] = rgb(64, 37, 29);
-wallColors[222][0] = rgb(70, 51, 91);
-wallColors[188][0] = rgb(82, 63, 80);
-wallColors[189][0] = rgb(65, 61, 77);
-wallColors[190][0] = rgb(64, 65, 92);
-wallColors[191][0] = rgb(76, 53, 84);
-wallColors[192][0] = rgb(144, 67, 52);
-wallColors[193][0] = rgb(149, 48, 48);
-wallColors[194][0] = rgb(111, 32, 36);
-wallColors[195][0] = rgb(147, 48, 55);
-wallColors[196][0] = rgb(97, 67, 51);
-wallColors[197][0] = rgb(112, 80, 62);
-wallColors[198][0] = rgb(88, 61, 46);
-wallColors[199][0] = rgb(127, 94, 76);
-wallColors[200][0] = rgb(143, 50, 123);
-wallColors[201][0] = rgb(136, 120, 131);
-wallColors[202][0] = rgb(219, 92, 143);
-wallColors[203][0] = rgb(113, 64, 150);
-wallColors[204][0] = rgb(74, 67, 60);
-wallColors[205][0] = rgb(60, 78, 59);
-wallColors[206][0] = rgb(0, 54, 21);
-wallColors[207][0] = rgb(74, 97, 72);
-wallColors[208][0] = rgb(40, 37, 35);
-wallColors[209][0] = rgb(77, 63, 66);
-wallColors[210][0] = rgb(111, 6, 6);
-wallColors[211][0] = rgb(88, 67, 59);
-wallColors[212][0] = rgb(88, 87, 80);
-wallColors[213][0] = rgb(71, 71, 67);
-wallColors[214][0] = rgb(76, 52, 60);
-wallColors[215][0] = rgb(89, 48, 59);
-wallColors[223][0] = rgb(51, 18, 4);
-wallColors[228][0] = rgb(160, 2, 75);
-wallColors[229][0] = rgb(100, 55, 164);
-wallColors[230][0] = rgb(0, 117, 101);
-wallColors[236][0] = rgb(127, 49, 44);
-wallColors[231][0] = rgb(110, 90, 78);
-wallColors[232][0] = rgb(47, 69, 75);
-wallColors[233][0] = rgb(91, 67, 70);
-wallColors[237][0] = rgb(200, 44, 18);
-wallColors[238][0] = rgb(24, 93, 66);
-wallColors[239][0] = rgb(160, 87, 234);
-wallColors[240][0] = rgb(6, 106, 255);
-wallColors[245][0] = rgb(102, 102, 102);
-wallColors[315][0] = rgb(181, 230, 29);
-wallColors[246][0] = rgb(61, 58, 78);
-wallColors[247][0] = rgb(52, 43, 45);
-wallColors[248][0] = rgb(81, 84, 101);
-wallColors[249][0] = rgb(85, 102, 103);
-wallColors[250][0] = rgb(52, 52, 52);
-wallColors[251][0] = rgb(52, 52, 52);
-wallColors[252][0] = rgb(52, 52, 52);
-wallColors[253][0] = rgb(52, 52, 52);
-wallColors[254][0] = rgb(52, 52, 52);
-wallColors[255][0] = rgb(52, 52, 52);
-wallColors[314][0] = rgb(52, 52, 52);
-wallColors[256][0] = rgb(40, 56, 50);
-wallColors[257][0] = rgb(49, 48, 36);
-wallColors[258][0] = rgb(43, 33, 32);
-wallColors[259][0] = rgb(31, 40, 49);
-wallColors[260][0] = rgb(48, 35, 52);
-wallColors[261][0] = rgb(88, 61, 46);
-wallColors[262][0] = rgb(55, 39, 26);
-wallColors[263][0] = rgb(39, 33, 26);
-wallColors[264][0] = rgb(43, 42, 68);
-wallColors[265][0] = rgb(30, 70, 80);
-wallColors[266][0] = rgb(78, 105, 135);
-wallColors[267][0] = rgb(51, 47, 96);
-wallColors[268][0] = rgb(101, 51, 51);
-wallColors[269][0] = rgb(62, 38, 41);
-wallColors[270][0] = rgb(59, 39, 22);
-wallColors[271][0] = rgb(59, 39, 22);
-wallColors[272][0] = rgb(111, 117, 135);
-wallColors[273][0] = rgb(25, 23, 54);
-wallColors[274][0] = rgb(52, 52, 52);
-wallColors[275][0] = rgb(149, 80, 51);
-wallColors[276][0] = rgb(82, 63, 80);
-wallColors[277][0] = rgb(65, 61, 77);
-wallColors[278][0] = rgb(64, 65, 92);
-wallColors[279][0] = rgb(76, 53, 84);
-wallColors[280][0] = rgb(144, 67, 52);
-wallColors[281][0] = rgb(149, 48, 48);
-wallColors[282][0] = rgb(111, 32, 36);
-wallColors[283][0] = rgb(147, 48, 55);
-wallColors[284][0] = rgb(97, 67, 51);
-wallColors[285][0] = rgb(112, 80, 62);
-wallColors[286][0] = rgb(88, 61, 46);
-wallColors[287][0] = rgb(127, 94, 76);
-wallColors[288][0] = rgb(143, 50, 123);
-wallColors[289][0] = rgb(136, 120, 131);
-wallColors[290][0] = rgb(219, 92, 143);
-wallColors[291][0] = rgb(113, 64, 150);
-wallColors[292][0] = rgb(74, 67, 60);
-wallColors[293][0] = rgb(60, 78, 59);
-wallColors[294][0] = rgb(0, 54, 21);
-wallColors[295][0] = rgb(74, 97, 72);
-wallColors[296][0] = rgb(40, 37, 35);
-wallColors[297][0] = rgb(77, 63, 66);
-wallColors[298][0] = rgb(111, 6, 6);
-wallColors[299][0] = rgb(88, 67, 59);
-wallColors[300][0] = rgb(88, 87, 80);
-wallColors[301][0] = rgb(71, 71, 67);
-wallColors[302][0] = rgb(76, 52, 60);
-wallColors[303][0] = rgb(89, 48, 59);
-wallColors[304][0] = rgb(158, 100, 64);
-wallColors[305][0] = rgb(62, 45, 75);
-wallColors[306][0] = rgb(57, 14, 12);
-wallColors[307][0] = rgb(96, 72, 133);
-wallColors[308][0] = rgb(67, 55, 80);
-wallColors[309][0] = rgb(64, 37, 29);
-wallColors[310][0] = rgb(70, 51, 91);
-wallColors[311][0] = rgb(51, 18, 4);
-wallColors[312][0] = rgb(78, 110, 51);
-wallColors[313][0] = rgb(78, 110, 51);
-wallColors[319][0] = rgb(105, 51, 108);
-wallColors[320][0] = rgb(75, 30, 15);
-wallColors[321][0] = rgb(91, 108, 130);
-wallColors[322][0] = rgb(91, 108, 130);
-wallColors[347][0] = rgb(100, 65, 130);
-wallColors[348][0] = rgb(120, 75, 75);
-var num7 = 0.5;
-wallColors[351][0] = tileColors[734][0] * num7;
-wallColors[352][0] = tileColors[735][0] * num7;
-wallColors[353][0] = tileColors[170][0] * num7;
-wallColors[354][0] = tileColors[736][0] * num7;
-wallColors[355][0] = tileColors[737][0] * num7;
-wallColors[356][0] = tileColors[738][0] * num7;
-wallColors[357][0] = tileColors[739][0] * num7;
-wallColors[358][0] = tileColors[741][0] * num7;
-wallColors[359][0] = tileColors[742][0] * num7;
-wallColors[360][0] = rgb(73, 93, 116);
-wallColors[361][0] = tileColors[744][0] * num7;
-wallColors[362][0] = tileColors[745][0] * num7;
-wallColors[363][0] = tileColors[746][0] * num7;
-wallColors[364][0] = tileColors[747][0] * num7;
-wallColors[365][0] = tileColors[748][0] * num7;
-wallColors[366][0] = tileColors[749][0] * num7;
-
-var array5 = new Array(256);
-var color5 = rgb(50, 40, 255);
-var color6 = rgb(145, 185, 255);
-for (var num8 = 0; num8 < array5.Length; num8++)
-{
-  var num9 = num8 / array5.Length;
-  var num10 = 1.0 - num9;
-  array5[num8] = rgb(((byte)(color5.r * num10 + color6.r * num9)), ((byte)(color5.g * num10 + color6.g * num9)), ((byte)(color5.b * num10 + color6.b * num9)));
-}
-var array6 = new Array(256);
-var color7 = rgb(88, 61, 46);
-var color8 = rgb(37, 78, 123);
-for (var num11 = 0; num11 < array6.Length; num11++)
-{
-  var num12 = num11 / 255.0;
-  var num13 = 1.0 - num12;
-  array6[num11] = rgb(((byte)(color7.r * num13 + color8.r * num12)), ((byte)(color7.g * num13 + color8.g * num12)), ((byte)(color7.b * num13 + color8.b * num12)));
-}
-var array7 = new Array(256);
-var color9 = rgb(74, 67, 60);
-color8 = rgb(53, 70, 97);
-for (var num14 = 0; num14 < array7.Length; num14++)
-{
-  var num15 = num14 / 255.0;
-  var num16 = 1.0 - num15;
-  array7[num14] = rgb(((byte)(color9.r * num16 + color8.r * num15)), ((byte)(color9.g * num16 + color8.g * num15)), ((byte)(color9.b * num16 + color8.b * num15)));
-}
-var color10 = rgb(50, 44, 38);
-var num17 = 0;
-var tileOptionCounts = new Array(tileColors.length);
-for (var num18 = 0; num18 < tileColors.length; num18++)
-{
-  var array8 = tileColors[num18];
-  var num19 = 0;
-  while (num19 < 13 && !(array8[num19] == rgb(0, 0, 0)))
-  {
-    num19++;
-  }
-  tileOptionCounts[num18] = num19;
-  num17 += num19;
-}
-wallOptionCounts = new Array(wallColors.length);
-for (var num20 = 0; num20 < wallColors.length; num20++)
-{
-  var array9 = wallColors[num20];
-  var num21 = 0;
-  while (num21 < 2 && !(array9[num21] == rgb(0, 0, 0)))
-  {
-    num21++;
-  }
-  wallOptionCounts[num20] = num21;
-  num17 += num21;
-}
-num17 += 774;
-colorLookup = new Array(num17);
-colorLookup[0] = rgb(0, 0, 0);
-var num22 = 1;
-tilePosition = num22;
-tileLookup = new Array(tileColors.length);
-for (var num23 = 0; num23 < tileColors.length; num23++)
-{
-  if (tileOptionCounts[num23] > 0)
-  {
-    var arg_81FD_0 = tileColors[num23];
-    tileLookup[num23] = num22;
-    for (var num24 = 0; num24 < tileOptionCounts[num23]; num24++)
-    {
-      colorLookup[num22] = tileColors[num23][num24];
-      num22 += 1;
-    }
-  }
-  else
-  {
-    tileLookup[num23] = 0;
-  }
-}
-wallPosition = num22;
-wallLookup = new Array(wallColors.length);
-wallRangeStart = num22;
-for (var num25 = 0; num25 < wallColors.length; num25++)
-{
-  if (wallOptionCounts[num25] > 0)
-  {
-    var arg_8288_0 = wallColors[num25];
-    wallLookup[num25] = num22;
-    for (var num26 = 0; num26 < wallOptionCounts[num25]; num26++)
-    {
-      colorLookup[num22] = wallColors[num25][num26];
-      num22 += 1;
-    }
-  }
-  else
-  {
-    wallLookup[num25] = 0;
-  }
-}
-wallRangeEnd = num22;
-liquidPosition = num22;
-for (var num27 = 0; num27 < 4; num27++)
-{
-  colorLookup[num22] = liquidColors[num27];
-  num22 += 1;
-}
-skyPosition = num22;
-for (var num28 = 0; num28 < 256; num28++)
-{
-  colorLookup[num22] = array5[num28];
-  num22 += 1;
-}
-dirtPosition = num22;
-for (var num29 = 0; num29 < 256; num29++)
-{
-  colorLookup[num22] = array6[num29];
-  num22 += 1;
-}
-rockPosition = num22;
-for (var num30 = 0; num30 < 256; num30++)
-{
-  colorLookup[num22] = array7[num30];
-  num22 += 1;
-}
-hellPosition = num22;
-colorLookup[num22] = color10;
-snowTypes = new Array(6);
-snowTypes[0] = tileLookup[147];
-snowTypes[1] = tileLookup[161];
-snowTypes[2] = tileLookup[162];
-snowTypes[3] = tileLookup[163];
-snowTypes[4] = tileLookup[164];
-snowTypes[5] = tileLookup[200];
diff --git a/resources/js/WorldLoader.js b/resources/js/WorldLoader.js
deleted file mode 100644
index 81c61a1..0000000
--- a/resources/js/WorldLoader.js
+++ /dev/null
@@ -1,898 +0,0 @@
-importScripts('MapHelper.js');
-importScripts('DataStream.js');
-importScripts('settings.js');
-
-self.addEventListener('message', function(e) {
-    self.start(e.data);
-}, false);
-
-var start = function(file) {
-    var fileReader = new FileReaderSync();
-
-    self.postMessage({
-        'status': "Reading world file..."
-    });
-
-    var buffer = fileReader.readAsArrayBuffer(file);
-
-    var ds = new DataStream(buffer);
-
-    ds.endianness = DataStream.LITTLE_ENDIAN;
-
-    var world = {};
-
-    self.postMessage({
-        'status': "Loading world file..."
-    });
-
-    readWorldFile(ds, world);
-};
-
-function logPosition(index, positions, reader, name) {
-    var expected = positions[index];
-    var actual = reader.position;
-    if (expected !== actual) {
-        console.error(`Position  ${index} wrong after reading ${name}: Expected ${expected}, actual ${actual}, diff ${expected - actual}`);
-    }
-}
-
-function readWorldFile(reader, world) {
-    var position = 0;
-    
-    const positions = readFileFormatHeader(reader, world);
-    logPosition(position++, positions, reader, 'format');
-
-    readHeader(reader, world);
-    logPosition(position++, positions, reader, 'header');
-
-    readTiles(reader, world);
-    logPosition(position++, positions, reader, 'tiles');
-    
-    readChests(reader, world);
-    logPosition(position++, positions, reader, 'chests');
-
-    readSigns(reader, world);
-    logPosition(position++, positions, reader, 'signs');
-
-    readNpcs(reader, world);
-    logPosition(position++, positions, reader, 'NPCs');
-
-    readTileEntities(reader, world);
-    logPosition(position++, positions, reader, 'entities');
-
-    self.postMessage({
-        'status': "Done.",
-        'done': true
-    });
-    console.log(world)
-}
-
-function readFileFormatHeader(reader, world) {
-    self.postMessage({
-        'status': "Reading world version..."
-    });
-
-    world.version = reader.readInt32();
-
-    self.postMessage({
-        'status': "Reading world header...",
-        'version': world.version,
-    });
-
-    // read file metadata
-    // TODO: implement readUint64()
-    reader.readUint32();
-    reader.readUint32();
-
-    world.revision = reader.readUint32();
-
-    // isFavorite
-    reader.readUint32();
-    reader.readUint32();
-
-    // read positions
-    var i = 0;
-
-    var positionsLength = reader.readInt16();
-    const positions = new Array(positionsLength);
-    for (i = 0; i < positionsLength; i++) {
-        positions[i] = reader.readInt32();
-    }
-
-    // read importance
-    var importanceLength = reader.readInt16();
-    world.importance = new Array(importanceLength);
-    var b = 0;
-    var b2 = 128;
-    for (i = 0; i < importanceLength; i++) {
-        if (b2 == 128) {
-            b = reader.readUint8();
-            b2 = 1;
-        } else {
-            b2 = b2 << 1;
-        }
-
-        if ((b & b2) == b2) {
-            world.importance[i] = true;
-        } else {
-            world.importance[i] = false;
-        }
-    }
-
-    return positions;
-}
-
-function readHeader(reader, world) {
-    world.name = readString(reader);
-
-    world.seed = readString(reader);
-
-    // world.worldGeneratorVersion
-    reader.readUint32();
-    reader.readUint32();
-
-    // UUID
-    for (i = 0; i < 16; i++) {
-        reader.readUint8();
-    }
-
-    world.id = reader.readInt32();
-
-    world.left = reader.readInt32();
-    world.right = reader.readInt32();
-    world.top = reader.readInt32();
-    world.bottom = reader.readInt32();
-
-    world.height = reader.readInt32();
-    world.width = reader.readInt32();
-
-    if (world.version >= 209) {
-        world.expertMode = world.gameMode = reader.readInt32();
-        if (world.version >= 222) {
-            world.drunkWorld = world.drunkMode = reader.readUint8();
-        }
-        if (world.version >= 227) {
-            world.getGoodWorld = reader.readUint8();
-        }
-        if (world.version >= 238) {
-            world.tenthAnniversaryWorld = reader.readUint8();
-        }
-        if (world.version >= 239) {
-            world.dontStarveWorld = reader.readUint8();
-        }
-        if (world.version >= 241) {
-            world.notTheBeesWorld = reader.readUint8();
-        }
-        if (world.version >= 249) {
-            world.remixWorld = reader.readUint8();
-        }
-        if (world.version >= 266) {
-            world.noTrapsWorld = reader.readUint8();
-        }
-        if (world.version >= 267) {
-            world.zenithWorld = reader.readUint8();
-        }
-        if (world.version >= 302)
-        {
-            world.skyblockWorld = reader.readUint8();
-        }
-    }
-
-    // creation time (Int64)
-    reader.readInt32();
-    reader.readInt32();
-
-    // last played (Int64)
-    reader.readInt32();
-    reader.readInt32();
-
-    world.moonType = reader.readUint8();
-
-    world.treeTypeXCoordinates = reader.readInt32Array(3);
-    world.treeStyles = reader.readInt32Array(4);
-    world.caveBackXCoordinates = reader.readInt32Array(3);
-    world.caveBackStyles = reader.readInt32Array(4);
-    world.iceBackStyle = reader.readInt32();
-    world.jungleBackStyle = reader.readInt32();
-    world.hellBackStyle = reader.readInt32();
-
-    world.spawnX = reader.readInt32();
-    world.spawnY = reader.readInt32();
-
-    world.worldSurfaceY = reader.readFloat64();
-    world.rockLayerY = reader.readFloat64();
-    world.gameTime = reader.readFloat64();
-    world.isDay = reader.readUint8() > 0;
-    world.moonPhase = reader.readInt32();
-    world.bloodMoon = reader.readUint8() > 0;
-    world.eclipse = reader.readUint8() > 0;
-    world.dungeonX = reader.readInt32();
-    world.dungeonY = reader.readInt32();
-    world.crimsonWorld = reader.readUint8() > 0;
-    world.killedEyeOfCthulu = reader.readUint8() > 0;
-    world.killedEaterOfWorlds = reader.readUint8() > 0;
-    world.killedSkeletron = reader.readUint8() > 0;
-    world.killedQueenBee = reader.readUint8() > 0;
-    world.killedTheDestroyer = reader.readUint8() > 0;
-    world.killedTheTwins = reader.readUint8() > 0;
-    world.killedSkeletronPrime = reader.readUint8() > 0;
-    world.killedAnyHardmodeBoss = reader.readUint8() > 0;
-    world.killedPlantera = reader.readUint8() > 0;
-    world.killedGolem = reader.readUint8() > 0;
-    world.killedSlimeKing = reader.readUint8() > 0;
-    world.savedGoblinTinkerer = reader.readUint8() > 0;
-    world.savedWizard = reader.readUint8() > 0;
-    world.savedMechanic = reader.readUint8() > 0;
-    world.defeatedGoblinInvasion = reader.readUint8() > 0;
-    world.killedClown = reader.readUint8() > 0;
-    world.defeatedFrostLegion = reader.readUint8() > 0;
-    world.defeatedPirates = reader.readUint8() > 0;
-    world.brokeAShadowOrb = reader.readUint8() > 0;
-    world.meteorSpawned = reader.readUint8() > 0;
-    world.shadowOrbsbrokenmod3 = reader.readUint8();
-    world.altarsSmashed = reader.readInt32();
-    world.hardMode = reader.readUint8() > 0;
-    world.afterPartyOfDoom = reader.readUint8() > 0;
-    world.goblinInvasionDelay = reader.readInt32();
-    world.goblinInvasionSize = reader.readInt32();
-    world.goblinInvasionType = reader.readInt32();
-    world.goblinInvasionX = reader.readFloat64();
-    world.slimeRainTime = reader.readFloat64();
-    world.sundialCooldown = reader.readUint8();
-    world.isRaining = reader.readUint8() > 0;
-    world.rainTime = reader.readInt32();
-    world.maxRain = reader.readFloat32();
-    world.tier1OreID = reader.readInt32();
-    world.tier2OreID = reader.readInt32();
-    world.tier3OreID = reader.readInt32();
-    world.treeStyle = reader.readUint8();
-    world.corruptionStyle = reader.readUint8();
-    world.jungleStyle = reader.readUint8();
-    world.snowStyle = reader.readUint8();
-    world.hallowStyle = reader.readUint8();
-    world.crimsonStyle = reader.readUint8();
-    world.desertStyle = reader.readUint8();
-    world.oceanStyle = reader.readUint8();
-    world.cloudBackground = reader.readInt32();
-    world.numberOfClouds = reader.readInt16();
-    world.windSpeed = reader.readFloat32();
-
-    world.anglerWhoFinishedTodayCount = reader.readInt32();
-    world.anglersWhoFinishedToday = [];
-
-    for (i = world.anglerWhoFinishedTodayCount; i > 0; i--) {
-        world.anglersWhoFinishedToday.push(readString(reader));
-    }
-
-    world.savedAngler = reader.readUint8() > 0;
-    world.anglerQuest = reader.readInt32();
-    world.savedStylist = reader.readUint8() > 0;
-    world.savedTaxCollector = reader.readUint8() > 0;
-    if (world.version >= 201) {
-        world.savedGolfer = reader.readUint8() > 0;
-    }
-
-    world.invasionSizeStart = reader.readInt32();
-    world.tempCultistDelay = reader.readInt32();
-
-    // banner system
-    let killedMobs = reader.readInt16();
-    for (var j = 0; j < killedMobs; j++) {
-        reader.readInt32();
-    }
-    killedMobs = reader.readInt16();
-    for (var j = 0; j < killedMobs; j++) {
-        reader.readInt16();
-    }
-
-    world.fastForwardTime = reader.readUint8() > 0;
-
-    world.downedFishron = reader.readUint8() > 0;
-    world.downedMartians = reader.readUint8() > 0;
-    world.downedAncientCultist = reader.readUint8() > 0;
-    world.downedMoonlord = reader.readUint8() > 0;
-    world.downedHalloweenKing = reader.readUint8() > 0;
-    world.downedHalloweenTree = reader.readUint8() > 0;
-    world.downedChristmasIceQueen = reader.readUint8() > 0;
-    world.downedChristmasSantank = reader.readUint8() > 0;
-    world.downedChristmasTree = reader.readUint8() > 0;
-    world.downedTowerSolar = reader.readUint8() > 0;
-    world.downedTowerVortex = reader.readUint8() > 0;
-    world.downedTowerNebula = reader.readUint8() > 0;
-    world.downedTowerStardust = reader.readUint8() > 0;
-
-    world.towerActiveSolar = reader.readUint8() > 0;
-    world.towerActiveVortex = reader.readUint8() > 0;
-    world.towerActiveNebula = reader.readUint8() > 0;
-    world.towerActiveStardust = reader.readUint8() > 0;
-    world.lunarApocalypseIsUp = reader.readUint8() > 0;
-
-    world.partyManual = reader.readUint8() > 0;
-    world.partyGenuine = reader.readUint8() > 0;
-    world.partyCooldown = reader.readInt32();
-
-    var num3 = world.partyingNPCS = reader.readInt32();
-    for (var k = 0; k < num3; k++) {
-        reader.readInt32();
-    }
-
-    world.sandstormHappening = reader.readUint8() > 0;
-    world.sandstormTimeLeft = reader.readInt32();
-
-    world.sandstormSeverity = reader.readFloat32();
-    world.sandstormIntendedSeverity = reader.readFloat32();
-
-    world.savedBartender = reader.readUint8() > 0;
-
-    world.downedInvasionTier1 = reader.readUint8() > 0;
-    world.downedInvasionTier2 = reader.readUint8() > 0;
-    world.downedInvasionTier3 = reader.readUint8() > 0;
-
-    // v1.4 Journey's End new stuff
-    // world bg stuff
-    if (world.version > 194) {
-        reader.readUint8();
-    }
-    if (world.version >= 215) {
-        reader.readUint8();
-    }
-    // tree bg stuff
-    if (world.version > 195) {
-        reader.readUint8();
-        reader.readUint8();
-        reader.readUint8();
-    }
-    if (world.version >= 204) {
-        world.combatBookWasUsed = reader.readUint8() > 0;
-    }
-    // tempLanternNight stuff
-    if (world.version >= 207) {
-        reader.readInt32();
-        reader.readUint8() > 0;
-        reader.readUint8() > 0;
-        reader.readUint8() > 0;
-    }
-
-    if (world.version >= 211) {
-        // tree tops info
-        var num = reader.readInt32();
-        num2 = 0;
-        while (num2 < num && num2 < 13) {
-            reader.readInt32();
-            num2++;
-        }
-    }
-    if (world.version >= 212) {
-        //forceHalloweenForToday
-        reader.readUint8() > 0;
-        // forceXMasForToday
-        reader.readUint8() > 0;
-    }
-    if (world.version >= 216) {
-        world.savedOreTiers = {};
-        world.savedOreTiers.copper = reader.readInt32();
-        world.savedOreTiers.iron = reader.readInt32();
-        world.savedOreTiers.silver = reader.readInt32();
-        world.savedOreTiers.gold = reader.readInt32();
-    }
-    if (world.version >= 217) {
-        world.boughtCat = reader.readUint8() > 0;
-        world.boughtDog = reader.readUint8() > 0;
-        world.boughtBunny = reader.readUint8() > 0;
-    }
-    if (world.version >= 223) {
-        world.downedEmpressOfLight = reader.readUint8() > 0;
-        world.downedQueenSlime = reader.readUint8() > 0;
-    }
-    if (world.version >= 240) {
-        world.downedDeerclops = reader.readUint8() > 0;
-    }
-
-    if (world.version >= 250) {
-        world.unlockedSlimeBlueSpawn = reader.readUint8() > 0;
-    }
-
-    if (world.version >= 251) {
-        world.unlockedMerchantSpawn = reader.readUint8() > 0;
-        world.unlockedDemolitionistSpawn = reader.readUint8() > 0;
-        world.unlockedPartyGirlSpawn = reader.readUint8() > 0;
-        world.unlockedDyeTraderSpawn = reader.readUint8() > 0;
-        world.unlockedTruffleSpawn = reader.readUint8() > 0;
-        world.unlockedArmsDealerSpawn = reader.readUint8() > 0;
-        world.unlockedNurseSpawn = reader.readUint8() > 0;
-        world.unlockedPrincessSpawn = reader.readUint8() > 0;
-    }
-
-    if (world.version >= 259) world.combatBookVolumeTwoWasUsed = reader.readUint8() > 0;
-    if (world.version >= 260) world.peddlersSatchelWasUsed = reader.readUint8() > 0;
-    if (world.version >= 261)
-    {
-      world.unlockedSlimeGreenSpawn = reader.readUint8() > 0;
-      world.unlockedSlimeOldSpawn = reader.readUint8() > 0;
-      world.unlockedSlimePurpleSpawn = reader.readUint8() > 0;
-      world.unlockedSlimeRainbowSpawn = reader.readUint8() > 0;
-      world.unlockedSlimeRedSpawn = reader.readUint8() > 0;
-      world.unlockedSlimeYellowSpawn = reader.readUint8() > 0;
-      world.unlockedSlimeCopperSpawn = reader.readUint8() > 0;
-    }
-    if (world.version >= 264)
-    {
-      reader.readUint8() > 0;
-      reader.readUint8();
-    }
-
-    if (world.version >= 287)
-    {
-        world.forceHalloweenForever = reader.readUint8();
-        world.forceXMasForever = reader.readUint8();
-    }
-    if (world.version >= 288)
-    {
-        world.vampireSeed = reader.readUint8();
-    }
-    else
-    {
-        world.vampireSeed = false;
-    }
-    if (world.version >= 296)
-    {
-        world.infectedSeed = reader.readUint8();
-    }
-    else
-    {
-        world.infectedSeed = false;
-    }
-    if (world.version >= 291)
-    {
-        world._tempMeteorShowerCount = reader.readInt32();
-        world._tempCoinRain = reader.readInt32();
-    }
-    else
-    {
-        world._tempMeteorShowerCount = 0;
-        world._tempCoinRain = 0;
-    }
-    if (world.version >= 297)
-    {
-        world.teamBasedSpawnsSeed = reader.readUint8();
-        const b = reader.readUint8();
-        for (let i = 0; i < b; i++) {
-            reader.readInt16();
-            reader.readInt16();
-        }
-    }
-    world.dualDungeonsSeed = (world.version >= 304 && reader.readUint8());
-    if (world.version >= 299 && world.version < 313)
-    {
-        reader.ReadUInt32();
-    }
-    // manifest
-    if (world.version >= 299) readString(reader);
-
-    var hellLevel = ((world.height - 230) - world.worldSurfaceY) / 6;
-    hellLevel = hellLevel * 6 + world.worldSurfaceY - 5;
-    world.hellLayerY = hellLevel;
-}
-
-function readTiles(reader, world) {
-    self.postMessage({
-        'status': "Reading world tiles...",
-        'world': world,
-    });
-
-    // 	world.tiles = [world.width, world.height];
-    world.totalTileCount = world.width * world.height;
-
-    var tilesProcessed = 0;
-
-    var color;
-    var num2 = -1;
-    var tile = {};
-    var b3 = 0;
-    var b4 = 0;
-    var k = 0;
-    var x = 0;
-    var y = 0;
-
-    // world.tiles = new Array(world.width);
-
-    var tiles = [];
-
-    for (x = 0; x < world.width; x++) {
-        // world.tiles[x] = new Array(world.height);
-
-        for (y = 0; y < world.height; y++) {
-            num2 = -1;
-            let b2 = 0;
-            let b = 0;
-            let tile = {};
-            let b3 = reader.readUint8();
-            let flag = false;
-            if ((b3 & 1) == 1) {
-                flag = true;
-                b2 = reader.readUint8();
-            }
-            let flag2 = false;
-            if (flag && (b2 & 1) == 1) {
-                flag2 = true;
-                b = reader.readUint8();
-            }
-            if (flag2 && (b & 1) == 1) {
-                b4 = reader.readUint8();
-            }
-            b4 = 0;
-            if ((b3 & 2) == 2) {
-                tile.IsActive = true;
-                if ((b3 & 32) == 32) {
-                    b4 = reader.readUint8();
-                    num2 = reader.readUint8();
-                    num2 = (num2 << 8 | b4);
-                } else {
-                    num2 = reader.readUint8();
-                }
-
-                tile.Type = num2;
-
-                if (world.importance[num2]) {
-                    tile.TextureU = reader.readInt16();
-                    tile.TextureV = reader.readInt16();
-                    if (tile.Type == 144) {
-                        tile.TextureV = 0;
-                    }
-                } else {
-                    tile.TextureU = -1;
-                    tile.TextureV = -1;
-                }
-                if ((b & 8) == 8) {
-                    // 	tile.ColorValue = reader.readUint8();
-                    reader.readUint8();
-                }
-            }
-            if ((b3 & 4) == 4) {
-                tile.WallType = reader.readUint8();
-                tile.IsWallPresent = true;
-                if ((b & 16) == 16) {
-                    tile.WallColor = reader.readUint8();
-                    tile.IsWallColorPresent = true;
-                }
-            }
-            b4 = (b3 & 0x18) >> 3;
-            if (b4 !== 0) {
-                tile.IsLiquidPresent = true;
-                tile.LiquidAmount = reader.readUint8();
-                if ((b & 128) == 128) {
-                    tile.Shimmer = true;
-                }
-                if (b4 > 1) {
-                    if (b4 == 2) {
-                        tile.IsLiquidLava = true;
-                    } else {
-                        tile.IsLiquidHoney = true;
-                    }
-                }
-            }
-            if (b2 > 1) {
-                if ((b2 & 2) == 2) {
-                    tile.IsRedWirePresent = true;
-                }
-                if ((b2 & 4) == 4) {
-                    tile.IsGreenWirePresent = true;
-                }
-                if ((b2 & 8) == 8) {
-                    tile.IsBlueWirePresent = true;
-                }
-                b4 = (b2 & 0x70) >> 4;
-            }
-            if (b > 0) {
-                if ((b & 2) == 2) {
-                    tile.IsActuatorPresent = true;
-                }
-                if ((b & 4) == 4) {
-                    tile.IsActive = false;
-                }
-                if ((b & 0x20) == 32) {
-                    tile.IsYellowWirePresent = true;
-                }
-                if ((b & 0x40) == 64) {
-                    b4 = reader.readUint8();
-                    tile.WallType = (b4 << 8 | tile.WallType);
-                }
-            }
-            b4 = (b3 & 192) >> 6;
-            k = 0;
-            switch ((b3 & 192) >> 6) {
-            case 0:
-                k = 0;
-                break;
-            case 1:
-                k = reader.readUint8();
-                break;
-            default:
-                k = reader.readUint16();
-                break;
-            }
-
-            tiles.push(tile);
-
-            while (k > 0) {
-                y++;
-
-                tiles.push(tile);
-
-                k--;
-            }
-        }
-
-        tilesProcessed += world.height;
-
-        if (x % 2 == 1) {
-            self.postMessage({
-                'status': `Reading tile ${tilesProcessed.toLocaleString()} of ${world.totalTileCount.toLocaleString()}`,
-                // 'tilesProcessed': tilesProcessed,
-                // 'totalTileCount': world.totalTileCount,
-                'x': x - 1,
-                'tiles': tiles,
-            });
-            tiles = [];
-        }
-    }
-}
-
-function readChests(reader, world) {
-    var chests = [];
-
-    var num = reader.readInt16();
-    var num2 = 0;
-
-    for (var i = 0; i < num; i++) {
-        var chest = {maxItems: 40};
-        chest.items = [];
-        chest.x = reader.readInt32();
-        chest.y = reader.readInt32();
-        chest.name = readString(reader);
-
-        var num3 = reader.readInt32();
-        num2 = num3;
-
-        var num4;
-        var num5;
-        if (num2 < num3)
-        {
-            num4 = num2;
-            num5 = 0;
-        }
-        else
-        {
-            num4 = chest.maxItems;
-            num5 = num2 - chest.maxItems;
-        }
-        for (var j = 0; j < num4; j++)
-        {
-            var num6 = reader.readInt16();
-            var item = {};
-            if (num6 > 0)
-            {
-                item.id = reader.readInt32();
-                item.count = num6;
-                item.prefixId = reader.readUint8();
-            }
-            else if (num6 < 0)
-            {
-                item.id = reader.readInt32();
-                item.prefixId = reader.readUint8();
-                item.count = 1;
-            }
-            if (item.count > 0) {
-                chest.items.push(item);
-            }
-        }
-        for (var k = 0; k < num5; k++)
-        {
-            var num6 = reader.readInt16();
-            if (num6 > 0)
-            {
-                reader.readInt32();
-                reader.readUint8();
-            }
-        }
-
-        chests.push(chest);
-    }
-
-    self.postMessage({
-        'chests': chests,
-    });
-}
-
-function readSigns(reader, world) {
-    var signs = [];
-
-    var num = reader.readInt16();
-
-    for (var i = 0; i < num; i++) {
-        var sign = {};
-
-        sign.text = readString(reader);
-        sign.x = reader.readInt32();
-        sign.y = reader.readInt32();
-
-        signs.push(sign);
-    }
-
-    self.postMessage({
-        'signs': signs,
-    });
-}
-
-function getNpcType(id) {
-    var npc = settings.Npcs.find((element) => element.Id === id);
-
-    if (npc) {
-        return npc.Name;
-    }
-
-    return "";
-}
-
-function readNpcs(reader, world) {
-    var npcs = [];
-
-    if (world.version >= 268) {
-        let num = reader.readInt32();
-        while(num-- > 0) {
-            reader.readInt32();
-        }
-    }
-
-    var num = 0;
-    var flag = reader.readUint8() > 0;
-
-    var npc;
-
-    while (flag) {
-        npc = {};
-        npc.spriteId = reader.readInt32();
-        npc.type = getNpcType(npc.spriteId);
-        npc.name = readString(reader);
-        npc.x = reader.readFloat32() / 16;
-        npc.y = reader.readFloat32() / 16;
-        npc.isHomeless = reader.readUint8() > 0;
-        npc.homeX = reader.readInt32();
-        npc.homeY = reader.readInt32();
-        if (world.version >= 213 && reader.readUint8() > 0) {
-            npc.townVariation = reader.readInt32();
-        }
-        npc.homelessDespawn = reader.readUint8() > 0;
-        npcs.push(npc);
-
-        num++;
-        flag = reader.readUint8() > 0;
-    }
-
-    flag = reader.readUint8() > 0;
-    while (flag) {
-        npc = {};
-        npc.spriteId = reader.readInt32();
-        // npc.type = readString(reader);
-        npc.x = reader.readFloat32();
-        npc.y = reader.readFloat32();
-        num++;
-        flag = reader.readUint8();
-    }
-
-    self.postMessage({
-        'npcs': npcs,
-    });
-}
-
-function readTileEntity(reader) {
-    let tileType = reader.readUint8();
-    if (tileType < 0 || tileType > 7) {
-        return null;
-    }
-    let tileEntity = {};
-    tileEntity.type = tileType;
-    tileEntity.id = reader.readInt32();
-    tileEntity.position = {x:reader.readInt16(), y:reader.readInt16()};
-    switch (tileType) {
-        case 0: // target dummy
-            reader.readInt16();
-            break;
-        case 1: // item frame
-        case 4: // weapon rack
-        case 6: // plate
-            tileEntity.item = {}
-            tileEntity.item.id = reader.readInt16();
-            tileEntity.item.prefixId = reader.readUint8();
-            tileEntity.item.count = reader.readInt16();
-            break;
-        case 2: // logic sensor
-            tileEntity.logicCheckType = reader.readUint8();
-            tileEntity.on = reader.readUint8() > 0;
-            break;
-        case 3: // (wo)mannequin
-            tileEntity.items = Array(8)
-            tileEntity.dyes = Array(8);
-            let itemBitmask = reader.readUint8();
-            let dyeBitmask = reader.readUint8();
-            for (let i = 0; i < 8; i++) {
-                tileEntity.items[i] = {
-                    id: 0
-                };
-                if (((itemBitmask >> i) & 1) === 1) {
-                    tileEntity.items[i].id = reader.readInt16();
-                    tileEntity.items[i].prefixId = reader.readUint8();
-                    tileEntity.items[i].count = reader.readInt16();
-                }
-            }
-            for (let j = 0; j < 8; j++) {
-                tileEntity.dyes[j] = {
-                    id: 0
-                };
-                if (((dyeBitmask >> j) & 1) === 1) {
-                    tileEntity.dyes[j].id = reader.readInt16();
-                    tileEntity.dyes[j].prefixId = reader.readUint8();
-                    tileEntity.dyes[j].count = reader.readInt16();
-                }
-            }
-            break;
-        case 5: // hat rack
-            tileEntity.items = Array(2)
-            tileEntity.dyes = Array(2);
-            let bitmask = reader.readUint8();
-            for (let i = 0; i < 2; i++) {
-                tileEntity.items[i] = {
-                    id: 0
-                };
-                if (((bitmask >> i) & 1) === 1) {
-                    tileEntity.items[i].id = reader.readInt16();
-                    tileEntity.items[i].prefixId = reader.readUint8();
-                    tileEntity.items[i].count = reader.readInt16();
-                }
-            }
-            for (let j = 0; j < 2; j++) {
-                tileEntity.dyes[j] = {
-                    id: 0
-                };
-                if (((bitmask >> (j+2)) & 1) === 1) {
-                    tileEntity.dyes[j].id = reader.readInt16();
-                    tileEntity.dyes[j].prefixId = reader.readUint8();
-                    tileEntity.dyes[j].count = reader.readInt16();
-                }
-            }
-            break;
-        case 7: // pylon
-            break;
-    }
-    return tileEntity;
-}
-
-function readTileEntities(reader, world) {
-    /** @type{Map<{x:int,y:int}, any>}*/
-    let byPosition = new Map();
-    let count = reader.readInt32();
-    for (let i = 0; i < count; i++) {
-        let tileEntity = readTileEntity(reader);
-        byPosition.set(tileEntity.position, tileEntity);
-    }
-    self.postMessage({
-        'tileEntities': byPosition,
-    });
-}
-
-function readString(reader) {
-    var stringLength = 0;
-    var stringLengthParsed = false;
-    var step = 0;
-    while (!stringLengthParsed) {
-        var part = reader.readUint8();
-        stringLengthParsed = ((part >> 7) === 0);
-        var partCutter = part & 127;
-        part = partCutter;
-        var toAdd = part << (step * 7);
-        stringLength += toAdd;
-        step++;
-    }
-
-    return reader.readString(stringLength);
-}
diff --git a/resources/js/main.js b/resources/js/main.js
index 93b49d9..e0b90c7 100644
--- a/resources/js/main.js
+++ b/resources/js/main.js
@@ -5,24 +5,10 @@ var canvas = document.querySelector("#canvas");
 var overlayCanvas = document.querySelector("#overlayCanvas");
 var selectionCanvas = document.querySelector("#selectionCanvas");
 
-var ctx = canvas.getContext("2d");
-var overlayCtx = overlayCanvas.getContext("2d");
 var selectionCtx = selectionCanvas.getContext("2d");
 
-var pixels = null;
-
 var blockSelector = document.querySelector("#blocks");
 
-ctx.msImageSmoothingEnabled = false;
-ctx.mozImageSmoothingEnabled = false;
-ctx.msImageSmoothingEnabled = false;
-ctx.imageSmoothingEnabled = false;
-
-overlayCtx.msImageSmoothingEnabled = false;
-overlayCtx.mozImageSmoothingEnabled = false;
-overlayCtx.msImageSmoothingEnabled = false;
-overlayCtx.imageSmoothingEnabled = false;
-
 selectionCtx.msImageSmoothingEnabled = false;
 selectionCtx.mozImageSmoothingEnabled = false;
 selectionCtx.msImageSmoothingEnabled = false;
@@ -32,6 +18,8 @@ var file;
 
 var world;
 
+var worker = null;
+
 var selectionX = 0;
 var selectionY = 0;
 
@@ -120,7 +108,7 @@ function highlightSet(setIndex) {
 
   // blockSelector.val(selectedValues);
 
-  highlightInfos(set.Entries);
+  worker.postMessage({ search: set.Entries });
 }
 
 function sortAndAddSelectOptions() {
@@ -319,137 +307,15 @@ function nextBlock(e) {
   findBlock(1);
 }
 
-function isTileMatch(tile, selectedInfos, x, y) {
-  for(var j = 0; j < selectedInfos.length; j++) {
-    var info = selectedInfos[j];
-
-    // check the tile first
-    if(tile.info && info.isTile && (tile.info == info || (!info.parent && tile.Type == info.Id)))
-      return true;
-
-    // check the wall
-    if(info.isWall && tile.WallType == info.Id)
-      return true;
-
-    // see if it's a chest
-    var chest = tile.chest;
-    if(chest && info.isItem) {
-      // see if the chest contains the item
-      for(var i = 0; i < chest.items.length; i++) {
-        var item = chest.items[i];
-
-        if(info.Id == item.id) {
-          return true;
-        }
-      }
-    }
-
-    // check if the tile entity contains it
-    let tileEntity = tile.tileEntity;
-    if (tileEntity && info.isItem) {
-      switch (tileEntity.type) {
-        case 1: // item frame
-        case 4: // weapon rack
-        case 6: // plate
-          if (info.Id == tileEntity.item.id) {
-            return true;
-          }
-          break;
-        case 3: // (wo)mannequin
-        case 5: // hat rack
-          for (let i = 0; i < tileEntity.items.length; i++) {
-            if (info.Id == tileEntity.items[i].id) {
-              return true;
-            }
-            if (info.Id == tileEntity.dyes[i].id) {
-              return true;
-            }
-          }
-          break;
-      }
-    }
-  }
-
-  return false;
-}
-
 function findBlock(direction) {
-  if(!world)
-    return;
-
-  var x = selectionX;
-  var y = selectionY + direction;
-
-  var start = x * world.height + y;
-
-  var selectedInfos = getSelectedInfos();
-
-  if(selectedInfos.length > 0) {
-    for(var i = start; i >= 0 && i < world.tiles.length; i += direction) {
-      var tile = world.tiles[i];
-
-      var foundMatch = false;
-
-      if(isTileMatch(tile, selectedInfos, x, y)) {
-        selectionX = x;
-        selectionY = y;
-
-        drawSelectionIndicator();
-        // panzoom.panzoom('pan', (-overlayCanvas.width / 2) - x, (-overlayCanvas.height / 2) - y, { relative: false });
-
-        foundMatch = true;
-
-        break;
-      }
-
-      y += direction;
-
-      if(y < 0 || y >= world.height) {
-        if(direction > 0)
-          y = 0;
-        else
-          y = world.height - 1;
-        x += direction;
-      }
-
-      if(foundMatch)
-        break;
-    }
-  }
+  worker?.postMessage?.({
+    findNext: { x: selectionX, y: selectionY, direction },
+  });
 }
 
 function highlightAll() {
-  if(!world)
-    return;
-
-  var selectedInfos = getSelectedInfos();
-
-  highlightInfos(selectedInfos);
-}
-
-function highlightInfos(selectedInfos) {
-  var x = 0;
-  var y = 0;
-
-  overlayCtx.clearRect(0, 0, overlayCanvas.width, overlayCanvas.height);
-  overlayCtx.fillStyle = "rgba(0, 0, 0, 0.75)";
-  overlayCtx.fillRect(0, 0, overlayCanvas.width, overlayCanvas.height);
-
-  if(selectedInfos.length > 0) {
-    for(var i = 0; i < world.tiles.length; i++) {
-      var tile = world.tiles[i];
-
-      if(isTileMatch(tile, selectedInfos)) {
-        overlayCtx.fillStyle = "rgb(255, 255, 255)";
-        overlayCtx.fillRect(x, y, 1, 1);
-      }
-
-      y++;
-      if(y >= world.height) {
-        y = 0;
-        x++;
-      }
-    }
+  if (world) {
+    worker.postMessage({ search: getSelectedInfos() });
   }
 }
 
@@ -538,36 +404,9 @@ function getWallInfoFromOption(option) {
   return null;
 }
 
-function getTileInfo(tile) {
-  var tileInfo = settings.Tiles[tile.Type];
-
-  if(!tileInfo) return tileInfo;
-
-  if(!tileInfo.Frames)
-    return tileInfo;
-
-  var matchingFrame;
-
-  for(var i = 0; i < tileInfo.Frames.length; i++) {
-    var frame = tileInfo.Frames[i];
-
-    if((!frame.U && !tile.TextureU) || frame.U <= tile.TextureU) {
-      if((!frame.V && !tile.TextureV) || frame.V <= tile.TextureV)
-        matchingFrame = frame;
-    }
-  }
-
-  if(!matchingFrame)
-    return tileInfo;
-
-  matchingFrame.parent = tileInfo;
-
-  return matchingFrame;
-}
-
 function clearHighlight() {
-  overlayCtx.clearRect(0, 0, overlayCanvas.width, overlayCanvas.height);
   selectionCtx.clearRect(0, 0, selectionCanvas.width, selectionCanvas.height);
+  worker?.postMessage?.({ clearHighlight: true });
 }
 
 function clearSelection() {
@@ -594,15 +433,13 @@ function resizeCanvases() {
 
 function getMousePos(canvas, evt) {
   var rect = panzoomContainer.getBoundingClientRect();
-  var transform = $(panzoomContainer).panzoom('getMatrix');
-
-  var scale = transform[0];
 
-  scale = rect.width / panzoomContainer.width;
+  const scaleX = rect.width / (panzoomContainer.width + 0.5);
+  const scaleY = rect.height / (panzoomContainer.height + 0.5);
 
   var mousePos =  {
-    x: Math.floor((evt.clientX - rect.left) / scale),
-    y: Math.floor((evt.clientY - rect.top) / scale)
+    x: Math.floor((evt.clientX - rect.left) / scaleX),
+    y: Math.floor((evt.clientY - rect.top) / scaleY)
   };
 
   // console.log(`${evt.clientX}\t${evt.clientY}\t${rect.left}\t${rect.top}\t${scale}\t${mousePos.x}\t${mousePos.y}`);
@@ -613,8 +450,8 @@ function getMousePos(canvas, evt) {
 function getItemText(item) {
   let prefix = "";
 
-  if(item.prefixId > 0 && item.prefixId < settings.ItemPrefix.length)
-    prefix = settings.ItemPrefix[item.prefixId].Name;
+  if(item.prefix > 0 && item.prefix < settings.ItemPrefix.length)
+    prefix = settings.ItemPrefix[item.prefix].Name;
 
   let itemName = item.id;
   for(let itemIndex = 0; itemIndex < settings.Items.length; itemIndex++) {
@@ -624,9 +461,11 @@ function getItemText(item) {
       break;
     }
   }
-  return `${prefix} ${itemName} (${item.count})`;
+  return `${prefix} ${itemName} (${item.stack})`;
 }
 
+var mouseMoveDebounce = null;
+var lastMouseMovePos = { x: 0, y: 0 };
 panzoomContainer.addEventListener('mousemove', evt => {
   if(!world)
     return;
@@ -635,16 +474,15 @@ panzoomContainer.addEventListener('mousemove', evt => {
   var x = mousePos.x;
   var y = mousePos.y;
 
-  $("#status").html(mousePos.x + ',' + (mousePos.y));
-
-  if(world.tiles) {
-    var tile = getTileAt(mousePos.x, mousePos.y);
-
-    if(tile) {
-      var text = getTileText(tile);
-
-      $("#status").html(`${text} (${mousePos.x}, ${mousePos.y})`);
-    }
+  clearTimeout(mouseMoveDebounce);
+  if (Math.hypot(lastMouseMovePos.x - x, lastMouseMovePos.y - y) > 20) {
+    worker.postMessage({ hoverTile: { x, y } });
+    lastMouseMovePos = { x, y };
+  } else {
+    mouseMoveDebounce = setTimeout(() => {
+      worker.postMessage({ hoverTile: { x, y } });
+      lastMouseMovePos = { x, y };
+    }, 75);
   }
 });
 
@@ -659,57 +497,7 @@ $("#panzoomContainer").on('panzoomend', function(evt, panzoom, matrix, changed)
   selectionY = y;
 
   drawSelectionIndicator();
-
-  var tile = getTileAt(x, y);
-  if(tile) {
-    var text = getTileText(tile);
-
-    $("#tileInfoList").html("");
-
-    var chest = tile.chest;
-    if(chest) {
-      if(chest.name.length > 0)
-      text = `${text} - ${chest.name}`;
-
-      for(var i = 0; i < chest.items.length; i++) {
-        let item = chest.items[i];
-        let itemText = getItemText(item);
-
-        $("#tileInfoList").append(`<li>${itemText}</li>`);
-      }
-    }
-
-    let tileEntity = tile.tileEntity;
-    if (tileEntity) {
-      switch (tileEntity.type) {
-        case 3: // mannequin
-        case 5: // hat rack
-          let items = tileEntity.items;
-          let dyes = tileEntity.dyes;
-          let itemLength = items.length;
-          for (let i = 0; i < itemLength; i++) {
-            let item = items[i];
-            if (item.id > 0) {
-              $("#tileInfoList").append(`<li>${getItemText(item)}</li>`);
-            }
-            let dye = dyes[i];
-            if (dye.id > 0) {
-              $("#tileInfoList").append(`<li>${getItemText(dye)}</li>`);
-            }
-          }
-          break;
-      }
-    }
-
-    var sign = tile.sign;
-    if(sign && sign.text) {
-      if(sign.text.length > 0)
-        $("#tileInfoList").append(`<li>${sign.text}</li>`);
-    }
-
-    $("#tile").html(text);
-  }
-
+  worker.postMessage({ selectTile: { x, y } });
 });
 
 function getTileAt(x, y) {
@@ -724,8 +512,8 @@ function getTileAt(x, y) {
 }
 
 function selectPoint(x, y) {
-  selectionX = x;
-  selectionY = y;
+  selectionX = Math.round(x);
+  selectionY = Math.round(y);
   drawSelectionIndicator();
 }
 
@@ -762,96 +550,29 @@ function drawSelectionIndicator() {
   selectionCtx.stroke();
 }
 
-function getTileText (tile) {
-  var text = "Nothing";
-
-  if(!tile) {
-    return text;
-  }
-
-  var tileInfo = tile.info;
-
-  if(tileInfo) {
-    if(!tileInfo.parent || !tileInfo.parent.Name) {
-       text = tileInfo.Name;
-    }
-    else if(tileInfo.parent && tileInfo.parent.Name) {
-      text = tileInfo.parent.Name;
-
-      if(tileInfo.Name) {
-        text = `${text} - ${tileInfo.Name}`;
-
-        if(tileInfo.Variety)
-        text = `${text} - ${tileInfo.Variety}`;
-      }
-      else if (tileInfo.Variety) {
-        text = `${text} - ${tileInfo.Variety}`;
-      }
-    }
-
-    if(tile.TextureU > 0 && tile.TextureV > 0)
-      text = `${text} (${tile.Type}, ${tile.TextureU}, ${tile.TextureV})`;
-    else if(tile.TextureU > 0)
-      text = `${text} (${tile.Type}, ${tile.TextureU})`;
-    else
-      text = `${text} (${tile.Type})`;
-    if (tile.tileEntity) {
-      let tileEntity = tile.tileEntity;
-      switch (tileEntity.type) {
-        case 1: // item frame
-        case 4: // weapon rack
-        case 6: // plate
-          let item = tileEntity.item;
-          let itemText = getItemText(item);
-          text = `${text} - ${itemText}`;
-          break;
-        case 2: // logic sensor
-          let checkType = tile.info.CheckTypes[tileEntity.logicCheckType];
-          let on = tileEntity.on ? "On" : "Off";
-          text = `${text} - ${checkType}, ${on}`;
-          break;
-      }
+function getTileInfoList(tile) {
+  const info = [];
+  const fields = [
+    ['actuated', 'Actuated'],
+    ['echoCoatBlock', 'Echo Coat Block'],
+    ['echoCoatWall', 'Echo Coat Wall'],
+    ['illuminantBlock', 'Illuminant Block'],
+    ['illuminantWall', 'Illuminant Wall'],
+    ['liquidAmount', 'Liquid Amount'],
+    ['slope', 'Slope'],
+  ];
+  for (const [key, label] of fields) {
+    if (tile[key]) {
+      info.push(`${label}: ${tile[key]}`);
     }
   }
-  else if (tile.WallType || tile.WallType === 0) {
-    if(tile.WallType < settings.Walls.length) {
-      text = `${settings.Walls[tile.WallType].Name} (${tile.WallType})`;
-    }
-    else {
-      text = `Unknown Wall (${tile.WallType})`;
-    }
+  if (tile.blockPaint > 0) {
+    info.push(`Block Paint: ${settings.Paints[tile.blockPaint].Name}`);
   }
-  
-  if (tile.IsLiquidPresent) {
-    if (text === "Nothing") text = "";
-
-    if(tile.IsLiquidLava) {
-      text += text ? " Lava" : "Lava";
-    }
-    else if (tile.IsLiquidHoney) {
-      text += text ? " Honey" : "Honey";
-    }
-    else if (tile.Shimmer) {
-      text += text ? " Shimmer" : "Shimmer";
-    }
-    else {
-      text += text ? " Water" : "Water";
-    }
+  if (tile.wallPaint > 0) {
+    info.push(`Wall Paint: ${settings.Paints[tile.wallPaint].Name}`);
   }
-
-  if(tile.IsRedWirePresent)
-    text += " (Red Wire)";
-
-  if(tile.IsGreenWirePresent)
-    text += " (Green Wire)";
-
-  if(tile.IsBlueWirePresent)
-    text += " (Blue Wire)";
-
-  if(tile.IsYellowWirePresent)
-    text += " (Yellow Wire)";
-
-  return text;
+  return info.sort();
 }
 
 function fileNameChanged (evt) {
@@ -863,113 +584,55 @@ function fileNameChanged (evt) {
 }
 
 function reloadWorld() {
-  var worker = new Worker('resources/js/WorldLoader.js');
-  worker.addEventListener('message', onWorldLoaderWorkerMessage);
+  if (worker === null) {
+    worker = new Worker('wasm/src/build/terramap.js');
+    worker.addEventListener('message', onWorldLoaderWorkerMessage);
+    const offscreen = canvas.transferControlToOffscreen();
+    const offscreenOverlay = overlayCanvas.transferControlToOffscreen();
+    worker.postMessage({ canvas: offscreen, overlayCanvas: offscreenOverlay }, [
+      offscreen,
+      offscreenOverlay,
+    ]);
+  }
 
-  worker.postMessage(file);
+  worker.postMessage({ file });
 }
 
 function onWorldLoaderWorkerMessage(e) {
   if(e.data.status)
     $("#status").html(e.data.status);
 
-  if (e.data.tiles) {
-    const bufferWidth = 200;
-    if (!pixels) {
-      pixels = new Uint8ClampedArray(4 * bufferWidth * world.height);
+  if (e.data.tile) {
+    $("#tileInfoList").empty();
+    const tile = e.data.tile;
+    for (const row of getTileInfoList(tile)) {
+      $("#tileInfoList").append(`<li>${row}</li>`);
     }
-    let xlimit = e.data.x + e.data.tiles.length / world.height;
-    let i = 0;
-    for (let x = e.data.x; x < xlimit; x++) {
-      const bufferStart = bufferWidth * Math.floor(x / bufferWidth);
-      if (x % bufferWidth === 0 && x > 0) {
-        const imageData = new ImageData(pixels, bufferWidth);
-        ctx.putImageData(imageData, bufferStart - bufferWidth, 0);
+    if (tile.chest) {
+      if (tile.chest.name.length > 0) {
+        tile.text += ` - ${tile.chest.name}`;
       }
-      for (let y = 0; y < world.height; y++) {
-        let tile = e.data.tiles[i++];
-        if (tile) {
-          tile.info = getTileInfo(tile);
-          world.tiles.push(tile);
-
-          let c = getTileColor(y, tile, world);
-          if (!c) c = { "r": 0, "g": 0, "b": 0 };
-
-          const pxIdx = 4 * (y * bufferWidth + x - bufferStart);
-          pixels[pxIdx] = c.r;
-          pixels[pxIdx + 1] = c.g;
-          pixels[pxIdx + 2] = c.b;
-          pixels[pxIdx + 3] = 255;
-        }
+      for (const item of tile.chest.items) {
+        $("#tileInfoList").append(`<li>${getItemText(item)}</li>`);
       }
     }
-  }
-
-  if (e.data.done) {
-    const bufferWidth = 200;
-    const bufferStart =
-      bufferWidth * Math.floor((world.width - 1) / bufferWidth);
-    const imageData = new ImageData(pixels, bufferWidth);
-    ctx.putImageData(imageData, bufferStart, 0);
-    pixels = null;
-  }
-
-  if(e.data.chests) {
-    world.chests = e.data.chests;
-
-    for(i = 0; i < e.data.chests.length; i++) {
-      var chest = e.data.chests[i];
-
-      var idx = chest.x * world.height + chest.y;
-      world.tiles[idx].chest = chest;
-      world.tiles[idx + 1].chest = chest;
-
-      idx = (chest.x + 1) * world.height + chest.y;
-      world.tiles[idx].chest = chest;
-      world.tiles[idx + 1].chest = chest;
-    }
-  }
-
-  if(e.data.signs) {
-    world.signs = e.data.signs;
-
-    for(i = 0; i < e.data.signs.length; i++) {
-      var sign = e.data.signs[i];
-
-      var tileIndex = sign.x * world.height + sign.y;
-      world.tiles[tileIndex].sign = sign;
-      world.tiles[tileIndex + 1].sign = sign;
-
-      tileIndex = (sign.x + 1) * world.height + sign.y;
-      world.tiles[tileIndex].sign = sign;
-      world.tiles[tileIndex + 1].sign = sign;
-    }
-  }
-
-  if(e.data.npcs) {
-    addNpcs(e.data.npcs);
-  }
-
-  if (e.data.tileEntities) {
-    for (const [pos, entity] of e.data.tileEntities.entries()) {
-      let idx = pos.x * world.height + pos.y;
-      let tile = world.tiles[idx];
-      if (tile) {
-        let size = tile.info.Size;
-        let sizeX = 1;
-        let sizeY = 1;
-        if (size) {
-          sizeX = size[0] - '0';
-          sizeY = size[2] - '0';
+    if (tile.tileEntity && tile.tileEntity.items.length > 1) {
+      const items = tile.tileEntity.items;
+      const dyes = tile.tileEntity.dyes;
+      for (let i = 0; i < items.length; ++i) {
+        if (items[i].id > 0) {
+          $("#tileInfoList").append(`<li>${getItemText(items[i])}</li>`);
         }
-        for (let x = 0; x < sizeX; x++) {
-          for (let y = 0; y < sizeY; y++) {
-            let idx = (pos.x+x) * world.height + pos.y+y;
-            world.tiles[idx].tileEntity = entity;
-          }
+        if (dyes[i]?.id > 0) {
+          $("#tileInfoList").append(`<li>${getItemText(dyes[i])}</li>`);
         }
       }
     }
+    if (tile.sign && tile.sign.text.length > 0) {
+      const signText = tile.sign.text.trim().replaceAll('\n', '<br>');
+      $("#tileInfoList").append(`<li>${signText}</li>`);
+    }
+    $("#tile").html(tile.text);
   }
 
   if(e.data.world) {
@@ -977,15 +640,9 @@ function onWorldLoaderWorkerMessage(e) {
 
     panzoomContainer.width = world.width;
     panzoomContainer.height = world.height;
-    canvas.width = world.width;
-    canvas.height = world.height;
-    overlayCanvas.width = world.width;
-    overlayCanvas.height = world.height;
     selectionCanvas.width = world.width;
     selectionCanvas.height = world.height;
 
-    world.tiles = [];
-
     resizeCanvases();
 
     $("#worldPropertyList").empty();
@@ -993,66 +650,39 @@ function onWorldLoaderWorkerMessage(e) {
     Object.keys(world).filter(key => {
       const value = world[key];
       const type = typeof value;
-      return type === 'string' || type === 'number' || type === 'boolean' || type === 'bigint';
+      return type === 'string' || type === 'number' || type === 'boolean' || type === 'bigint' || (
+        Array.isArray(value) && value.length < 5 && key !== 'npcs' && key !== 'signs'
+      );
     }).sort()
     .forEach(key => 
-      $("#worldPropertyList").append(`<li>${key}: ${world[key]}</li>`)
+      $("#worldPropertyList").append(
+        `<li>${key}: ${Array.isArray(world[key]) ? JSON.stringify(world[key]) : world[key]}</li>`
+      )
     );
+
+    addNpcs(world.npcs);
+  }
+
+  if (e.data.select) {
+    selectPoint(e.data.select.x, e.data.select.y);
   }
 }
 
 function addNpcs(npcs) {
-  world.npcs = npcs;
+  $("#npcList").empty();
 
   for(var i = 0; i < npcs.length; i++) {
     var npc = npcs[i];
 
-    var npcText = npc.name;
-    if(npc.type != npc.name) {
-      npcText = `${npcText} the ${npc.type}`;
+    var npcText = npc.type;
+    if (npc.name && npc.type != npc.name) {
+      npcText = `${npc.name} the ${npc.type}`;
     }
 
     $("#npcList").append(`<li><a href="#" onclick="selectPoint(${npc.x}, ${npc.y})">${npcText}</a></li>`);
   }
 }
 
-function getTileColor(y, tile, world) {
-  if(tile.IsActive) {
-    return tileColors[tile.Type][0];
-  }
-
-  if (tile.IsLiquidPresent) {
-    if(tile.IsLiquidLava)
-      return liquidColors[1];
-    else if (tile.IsLiquidHoney)
-      return liquidColors[2];
-    else if (tile.Shimmer)
-      return liquidColors[3];
-    else
-      return liquidColors[0];
-  }
-
-  if (tile.IsWallPresent) {
-    let color = wallColors[tile.WallType][0];
-    if (!color || (color.r === 0 && color.g === 0 && color.b === 0)) {
-      const wall = settings.Walls.find(w => w.Id === tile.WallType.toString());
-      if (wall && wall.Color) return wall.Color;
-    }
-    return color;
-  }
-
-  if(y < world.worldSurfaceY)
-    return { "r": 132, "g": 170, "b": 248 };
-
-  if(y < world.rockLayerY)
-    return { "r": 88, "g": 61, "b": 46 };
-
-  if(y < world.hellLayerY)
-    return { "r": 74, "g": 67, "b": 60 };
-
-  return { "r": 0, "g": 0, "b": 0 };
-}
-
 function saveMapImage() {
   var newCanvas = document.createElement("canvas");
   var newContext = newCanvas.getContext("2d");
diff --git a/resources/js/settings.js b/resources/js/settings.js
index 847d660..e840258 100644
--- a/resources/js/settings.js
+++ b/resources/js/settings.js
@@ -44959,6 +44959,40 @@ var settings = {
       Name: "Mythical",
     },
   ],
+  Paints: [
+    { Id: 0, Name: "None" },
+    { Id: 1, Name: "Red" },
+    { Id: 2, Name: "Orange" },
+    { Id: 3, Name: "Yellow" },
+    { Id: 4, Name: "Lime" },
+    { Id: 5, Name: "Green" },
+    { Id: 6, Name: "Teal" },
+    { Id: 7, Name: "Cyan" },
+    { Id: 8, Name: "Sky Blue" },
+    { Id: 9, Name: "Blue" },
+    { Id: 10, Name: "Purple" },
+    { Id: 11, Name: "Violet" },
+    { Id: 12, Name: "Pink" },
+    { Id: 13, Name: "Deep Red" },
+    { Id: 14, Name: "Deep Orange" },
+    { Id: 15, Name: "Deep Yellow" },
+    { Id: 16, Name: "Deep Lime" },
+    { Id: 17, Name: "Deep Green" },
+    { Id: 18, Name: "Deep Teal" },
+    { Id: 19, Name: "Deep Cyan" },
+    { Id: 20, Name: "Deep Sky Blue" },
+    { Id: 21, Name: "Deep Blue" },
+    { Id: 22, Name: "Deep Purple" },
+    { Id: 23, Name: "Deep Violet" },
+    { Id: 24, Name: "Deep Pink" },
+    { Id: 25, Name: "Black" },
+    { Id: 26, Name: "White" },
+    { Id: 27, Name: "Gray" },
+    { Id: 28, Name: "Brown" },
+    { Id: 29, Name: "Shadow" },
+    { Id: 30, Name: "Negative" },
+    { Id: 31, Name: "Illuminant Paint" },
+  ],
 };
 
 for (var wall of settings.Walls) {
diff --git a/wasm/src/.clang-format b/wasm/src/.clang-format
new file mode 100644
index 0000000..2cc3824
--- /dev/null
+++ b/wasm/src/.clang-format
@@ -0,0 +1,137 @@
+---
+Language:        Cpp
+# BasedOnStyle:  LLVM
+AccessModifierOffset: -4
+AlignAfterOpenBracket: AlwaysBreak
+AlignConsecutiveMacros: false
+AlignConsecutiveAssignments: false
+AlignConsecutiveDeclarations: false
+AlignEscapedNewlines: Right
+AlignOperands:   true
+AlignTrailingComments: true
+AllowAllArgumentsOnNextLine: false
+AllowAllConstructorInitializersOnNextLine: true
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: Never
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: Empty
+AllowShortLambdasOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: Never
+AllowShortLoopsOnASingleLine: false
+AlwaysBreakAfterDefinitionReturnType: None
+AlwaysBreakAfterReturnType: None
+AlwaysBreakBeforeMultilineStrings: false
+AlwaysBreakTemplateDeclarations: MultiLine
+BinPackArguments: false
+BinPackParameters: false
+BraceWrapping:
+  AfterCaseLabel:  false
+  AfterClass:      false
+  AfterControlStatement: false
+  AfterEnum:       false
+  AfterFunction:   false
+  AfterNamespace:  false
+  AfterObjCDeclaration: false
+  AfterStruct:     false
+  AfterUnion:      false
+  AfterExternBlock: false
+  BeforeCatch:     false
+  BeforeElse:      false
+  IndentBraces:    false
+  SplitEmptyFunction: true
+  SplitEmptyRecord: true
+  SplitEmptyNamespace: true
+BreakBeforeBinaryOperators: None
+BreakBeforeBraces: Linux
+BreakBeforeInheritanceComma: false
+BreakInheritanceList: BeforeColon
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializersBeforeComma: false
+BreakConstructorInitializers: BeforeColon
+BreakAfterJavaFieldAnnotations: false
+BreakStringLiterals: true
+ColumnLimit:     80
+CommentPragmas:  '^ IWYU pragma:'
+CompactNamespaces: false
+ConstructorInitializerAllOnOneLineOrOnePerLine: false
+ConstructorInitializerIndentWidth: 4
+ContinuationIndentWidth: 4
+Cpp11BracedListStyle: true
+DeriveLineEnding: true
+DerivePointerAlignment: false
+DisableFormat:   false
+ExperimentalAutoDetectBinPacking: false
+FixNamespaceComments: true
+ForEachMacros:
+  - foreach
+  - Q_FOREACH
+  - BOOST_FOREACH
+IncludeBlocks:   Preserve
+IncludeCategories:
+  - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
+    Priority:        2
+    SortPriority:    0
+  - Regex:           '^(<|"(gtest|gmock|isl|json)/)'
+    Priority:        3
+    SortPriority:    0
+  - Regex:           '.*'
+    Priority:        1
+    SortPriority:    0
+IncludeIsMainRegex: '(Test)?$'
+IncludeIsMainSourceRegex: ''
+IndentCaseLabels: false
+IndentCaseBlocks: false
+IndentGotoLabels: true
+IndentPPDirectives: None
+IndentWidth:     4
+IndentWrappedFunctionNames: false
+JavaScriptQuotes: Leave
+JavaScriptWrapImports: true
+KeepEmptyLinesAtTheStartOfBlocks: true
+MacroBlockBegin: ''
+MacroBlockEnd:   ''
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCBinPackProtocolList: Auto
+ObjCBlockIndentWidth: 2
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: true
+PenaltyBreakAssignment: 2
+PenaltyBreakBeforeFirstCallParameter: 19
+PenaltyBreakComment: 300
+PenaltyBreakFirstLessLess: 120
+PenaltyBreakString: 1000
+PenaltyBreakTemplateDeclaration: 10
+PenaltyExcessCharacter: 1000000
+PenaltyReturnTypeOnItsOwnLine: 60
+PointerAlignment: Right
+ReflowComments:  true
+SortIncludes:    true
+SortUsingDeclarations: true
+SpaceAfterCStyleCast: false
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: true
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyBlock: false
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 1
+SpacesInAngles:  false
+SpacesInConditionalStatement: false
+SpacesInContainerLiterals: true
+SpacesInCStyleCastParentheses: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+SpaceBeforeSquareBrackets: false
+Standard:        Latest
+StatementMacros:
+  - Q_UNUSED
+  - QT_REQUIRE_VERSION
+TabWidth:        8
+UseCRLF:         false
+UseTab:          Never
+...
diff --git a/wasm/src/.gitignore b/wasm/src/.gitignore
new file mode 100644
index 0000000..567609b
--- /dev/null
+++ b/wasm/src/.gitignore
@@ -0,0 +1 @@
+build/
diff --git a/wasm/src/Makefile b/wasm/src/Makefile
new file mode 100644
index 0000000..8f17c40
--- /dev/null
+++ b/wasm/src/Makefile
@@ -0,0 +1,44 @@
+# Config values
+
+CXXFLAGS := -Wall -Wextra -pedantic -Werror -Wno-dollar-in-identifier-extension \
+            -std=c++20 -O2
+LDFLAGS := -lembind                   \
+           -sENVIRONMENT=worker       \
+           -sALLOW_MEMORY_GROWTH=1    \
+           -sSTACK_SIZE=16MB          \
+           --extern-pre-js header.js  \
+           --pre-js pre.js            \
+           --extern-post-js worker.js \
+           -O2 --closure 1
+
+SRCS := main.cpp Reader.cpp TileColor.cpp World.cpp WorldLoader.cpp
+OUT := terramap
+
+BUILD_DIR := build
+
+
+# Build rules.
+
+CPPFLAGS := -Isrc
+
+OBJS := $(SRCS:%=$(BUILD_DIR)/%.o)
+
+$(BUILD_DIR)/$(OUT).js: $(OBJS) header.js pre.js worker.js
+	$(CXX) $(OBJS) -o $@ $(LDFLAGS)
+
+$(BUILD_DIR)/%.cpp.o: %.cpp
+	@mkdir -p $(dir $@)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) -c $< -o $@
+
+$(BUILD_DIR)/$(OUT): $(OBJS)
+	$(CXX) $(OBJS) -o $@
+
+cli: $(BUILD_DIR)/$(OUT)
+
+clean:
+	rm -r $(BUILD_DIR)
+
+format:
+	clang-format -i $(SRCS)
+
+.PHONY: cli clean format
diff --git a/wasm/src/Reader.cpp b/wasm/src/Reader.cpp
new file mode 100644
index 0000000..c862679
--- /dev/null
+++ b/wasm/src/Reader.cpp
@@ -0,0 +1,119 @@
+#include "Reader.h"
+#include "ieee754_types.hpp"
+
+#include <bit>
+
+typedef IEEE_754::_2008::Binary<32> float32_t;
+typedef IEEE_754::_2008::Binary<64> float64_t;
+
+namespace
+{
+
+template <typename NumberType, size_t byteCount>
+NumberType readLittleEndian(const char *buffer)
+{
+    NumberType result = 0;
+    for (int i = byteCount - 1; i >= 0; --i) {
+        result <<= 8;
+        result |= static_cast<unsigned char>(buffer[i]);
+    }
+    return result;
+}
+
+} // namespace
+
+Reader::Reader(const std::string &d) : pos(0), data(d) {}
+
+std::vector<bool> Reader::getBitVec()
+{
+    int len = getUint16();
+    std::vector<bool> result;
+    uint8_t buf = 0;
+    for (int i = 0, offset = 0; i < len; ++i, ++offset) {
+        if (offset % 8 == 0) {
+            buf = getUint8();
+            offset = 0;
+        }
+        result.push_back((buf & (1 << offset)) != 0);
+    }
+    return result;
+}
+
+bool Reader::getBool()
+{
+    return getUint8() != 0;
+}
+
+double Reader::getFloat32()
+{
+    return std::bit_cast<float32_t>(getUint32());
+}
+
+double Reader::getFloat64()
+{
+    return std::bit_cast<float64_t>(getUint64());
+}
+
+std::string Reader::getString()
+{
+    if (pos + 1 > data.size()) {
+        return {};
+    }
+    // LEB128 encoded length prefix.
+    size_t len = 0;
+    size_t shift = 0;
+    uint8_t b;
+    do {
+        b = getUint8();
+        len |= (b & 0x7f) << shift;
+        shift += 7;
+    } while ((b & 0x80) != 0);
+    std::string result = data.substr(pos, len);
+    pos += len;
+    return result;
+}
+
+uint8_t Reader::getUint8()
+{
+    if (pos + 1 > data.size()) {
+        return {};
+    }
+    uint8_t result = data[pos];
+    pos += 1;
+    return result;
+}
+
+uint16_t Reader::getUint16()
+{
+    if (pos + 2 > data.size()) {
+        return {};
+    }
+    uint16_t result = readLittleEndian<uint16_t, 2>(data.c_str() + pos);
+    pos += 2;
+    return result;
+}
+
+uint32_t Reader::getUint32()
+{
+    if (pos + 4 > data.size()) {
+        return {};
+    }
+    uint32_t result = readLittleEndian<uint32_t, 4>(data.c_str() + pos);
+    pos += 4;
+    return result;
+}
+
+uint64_t Reader::getUint64()
+{
+    if (pos + 8 > data.size()) {
+        return {};
+    }
+    uint64_t result = readLittleEndian<uint64_t, 8>(data.c_str() + pos);
+    pos += 8;
+    return result;
+}
+
+void Reader::skipBytes(size_t len)
+{
+    pos += len;
+}
diff --git a/wasm/src/Reader.h b/wasm/src/Reader.h
new file mode 100644
index 0000000..0b352c1
--- /dev/null
+++ b/wasm/src/Reader.h
@@ -0,0 +1,29 @@
+#ifndef READER_H
+#define READER_H
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+class Reader
+{
+private:
+    size_t pos;
+    const std::string &data;
+
+public:
+    Reader(const std::string &d);
+
+    std::vector<bool> getBitVec();
+    bool getBool();
+    double getFloat32();
+    double getFloat64();
+    std::string getString();
+    uint8_t getUint8();
+    uint16_t getUint16();
+    uint32_t getUint32();
+    uint64_t getUint64();
+    void skipBytes(size_t len);
+};
+
+#endif // READER_H
diff --git a/wasm/src/Tile.h b/wasm/src/Tile.h
new file mode 100644
index 0000000..d97d3ec
--- /dev/null
+++ b/wasm/src/Tile.h
@@ -0,0 +1,32 @@
+#ifndef TILE_H
+#define TILE_H
+
+enum class Liquid { none, water, lava, honey, shimmer };
+
+enum class Slope { none = 0, half, topRight, topLeft, bottomRight, bottomLeft };
+
+class Tile
+{
+public:
+    int blockId;
+    int frameX;
+    int frameY;
+    int wallId;
+    int blockPaint;
+    int wallPaint;
+    int liquidAmount;
+    Liquid liquid;
+    Slope slope;
+    bool wireRed : 1;
+    bool wireBlue : 1;
+    bool wireGreen : 1;
+    bool wireYellow : 1;
+    bool actuated : 1;
+    bool actuator : 1;
+    bool echoCoatBlock : 1;
+    bool echoCoatWall : 1;
+    bool illuminantBlock : 1;
+    bool illuminantWall : 1;
+};
+
+#endif // TILE_H
diff --git a/wasm/src/TileColor.cpp b/wasm/src/TileColor.cpp
new file mode 100644
index 0000000..ee30f81
--- /dev/null
+++ b/wasm/src/TileColor.cpp
@@ -0,0 +1,482 @@
+#include "TileColor.h"
+
+#include "World.h"
+#include <algorithm>
+
+namespace
+{
+// clang-format off
+uint8_t blockColors[] = {
+    151, 107, 75, 128, 128, 128, 28, 216, 94, 26, 196, 84, 253, 221, 3, 151,
+    107, 75, 140, 101, 80, 150, 67, 22, 185, 164, 23, 185, 194, 195, 119, 105,
+    79, 119, 105, 79, 174, 24, 69, 133, 213, 247, 191, 142, 111, 191, 142, 111,
+    140, 130, 116, 144, 148, 144, 191, 142, 111, 191, 142, 111, 163, 116, 81,
+    174, 129, 92, 98, 95, 167, 141, 137, 223, 122, 116, 218, 109, 90, 128, 119,
+    101, 125, 54, 154, 54, 151, 79, 80, 175, 105, 128, 151, 107, 75, 141, 120,
+    168, 151, 135, 183, 253, 221, 3, 235, 166, 135, 226, 145, 30, 230, 89, 92,
+    104, 86, 84, 128, 128, 128, 181, 62, 59, 146, 81, 68, 66, 84, 109, 251,
+    235, 127, 84, 100, 63, 107, 68, 99, 185, 164, 23, 185, 194, 195, 150, 67,
+    22, 128, 128, 128, 89, 201, 255, 170, 48, 114, 192, 202, 203, 23, 177, 76,
+    186, 168, 84, 200, 246, 254, 191, 142, 111, 43, 40, 84, 68, 68, 76, 142,
+    66, 66, 92, 68, 73, 143, 215, 29, 135, 196, 26, 121, 176, 24, 110, 140,
+    182, 196, 96, 114, 56, 150, 97, 160, 118, 58, 140, 58, 166, 125, 191, 197,
+    190, 150, 92, 93, 127, 255, 182, 175, 130, 182, 175, 130, 27, 197, 109, 96,
+    197, 27, 26, 26, 26, 142, 66, 66, 238, 85, 70, 121, 110, 97, 191, 142, 111,
+    73, 120, 17, 245, 133, 191, 246, 197, 26, 246, 197, 26, 246, 197, 26, 192,
+    192, 192, 191, 142, 111, 191, 142, 111, 191, 142, 111, 191, 142, 111, 144,
+    148, 144, 13, 88, 130, 213, 229, 237, 253, 221, 3, 191, 142, 111, 255, 162,
+    31, 144, 148, 144, 144, 148, 144, 253, 221, 3, 144, 148, 144, 253, 221, 3,
+    191, 142, 111, 229, 212, 73, 141, 98, 77, 191, 142, 111, 144, 148, 144,
+    191, 142, 111, 11, 80, 143, 91, 169, 169, 78, 193, 227, 48, 186, 135, 128,
+    26, 52, 103, 98, 122, 48, 208, 234, 191, 142, 111, 33, 171, 207, 238, 225,
+    218, 181, 172, 190, 238, 225, 218, 107, 92, 108, 92, 68, 73, 11, 80, 143,
+    91, 169, 169, 106, 107, 118, 73, 51, 36, 141, 175, 255, 159, 209, 229, 128,
+    204, 230, 191, 142, 111, 255, 117, 224, 128, 128, 128, 52, 52, 52, 144,
+    148, 144, 231, 53, 56, 166, 187, 153, 253, 114, 114, 213, 203, 204, 144,
+    148, 144, 128, 128, 128, 191, 142, 111, 98, 95, 167, 192, 59, 59, 144, 148,
+    144, 144, 148, 144, 144, 148, 144, 192, 30, 30, 43, 192, 30, 211, 236, 241,
+    211, 236, 241, 220, 50, 50, 128, 26, 52, 190, 171, 94, 128, 133, 184, 239,
+    141, 126, 190, 171, 94, 131, 162, 161, 170, 171, 157, 104, 100, 126, 145,
+    81, 85, 148, 133, 98, 255, 76, 76, 144, 195, 232, 184, 219, 240, 174, 145,
+    214, 218, 182, 204, 115, 173, 229, 129, 125, 93, 62, 82, 114, 132, 157,
+    127, 152, 171, 198, 27, 109, 69, 33, 135, 85, 191, 142, 111, 253, 221, 3,
+    253, 221, 3, 129, 125, 93, 132, 157, 127, 152, 171, 198, 208, 94, 201, 49,
+    134, 114, 126, 134, 49, 134, 59, 49, 43, 86, 140, 121, 49, 134, 29, 106,
+    88, 99, 99, 99, 99, 99, 99, 99, 99, 99, 73, 120, 17, 223, 255, 255, 182,
+    175, 130, 151, 107, 75, 26, 196, 84, 56, 121, 255, 157, 157, 107, 134, 22,
+    34, 147, 144, 178, 97, 200, 225, 62, 61, 52, 208, 80, 80, 216, 152, 144,
+    203, 61, 64, 213, 178, 28, 128, 44, 45, 125, 55, 65, 186, 50, 52, 124, 175,
+    201, 144, 148, 144, 88, 105, 118, 144, 148, 144, 192, 59, 59, 191, 233,
+    115, 144, 148, 144, 137, 120, 67, 103, 103, 103, 254, 121, 2, 191, 142,
+    111, 144, 148, 144, 144, 148, 144, 144, 148, 144, 144, 148, 144, 239, 90,
+    50, 231, 96, 228, 57, 85, 101, 107, 132, 139, 227, 125, 22, 141, 56, 0, 74,
+    197, 155, 144, 148, 144, 255, 156, 12, 131, 79, 13, 224, 194, 101, 145, 81,
+    85, 107, 182, 29, 53, 44, 41, 214, 184, 46, 149, 232, 87, 255, 241, 51,
+    225, 128, 206, 224, 194, 101, 120, 85, 60, 77, 74, 72, 99, 50, 30, 198,
+    196, 170, 200, 245, 253, 99, 50, 30, 99, 50, 30, 140, 150, 150, 219, 71,
+    38, 235, 38, 231, 86, 85, 92, 235, 150, 23, 153, 131, 44, 57, 48, 97, 248,
+    158, 92, 107, 49, 154, 154, 148, 49, 49, 49, 154, 49, 154, 68, 154, 49, 77,
+    85, 89, 118, 154, 83, 49, 221, 79, 255, 250, 255, 79, 79, 102, 255, 79,
+    255, 89, 255, 79, 79, 240, 240, 247, 255, 145, 79, 191, 142, 111, 187, 255,
+    107, 107, 250, 255, 121, 119, 101, 128, 128, 128, 190, 171, 94, 122, 217,
+    232, 122, 217, 232, 122, 217, 232, 122, 217, 232, 122, 217, 232, 122, 217,
+    232, 122, 217, 232, 122, 217, 232, 128, 128, 128, 150, 67, 22, 122, 217,
+    232, 122, 217, 232, 79, 128, 17, 122, 217, 232, 122, 217, 232, 122, 217,
+    232, 122, 217, 232, 122, 217, 232, 122, 217, 232, 122, 217, 232, 122, 217,
+    232, 122, 217, 232, 122, 217, 232, 122, 217, 232, 122, 217, 232, 144, 148,
+    144, 144, 148, 144, 144, 148, 144, 144, 148, 144, 144, 148, 144, 144, 148,
+    144, 144, 148, 144, 144, 148, 144, 144, 148, 144, 122, 217, 232, 122, 217,
+    232, 117, 61, 25, 204, 93, 73, 87, 150, 154, 181, 164, 125, 235, 114, 80,
+    157, 176, 226, 118, 227, 129, 227, 118, 215, 96, 68, 48, 203, 185, 151, 96,
+    77, 64, 198, 170, 104, 182, 141, 86, 228, 213, 173, 129, 125, 93, 9, 61,
+    191, 253, 32, 3, 200, 246, 254, 15, 15, 15, 226, 118, 76, 161, 172, 173,
+    204, 181, 72, 190, 190, 178, 191, 142, 111, 217, 174, 137, 253, 62, 3, 144,
+    148, 144, 85, 255, 160, 122, 217, 232, 96, 248, 2, 105, 74, 202, 29, 240,
+    255, 254, 202, 80, 131, 252, 245, 255, 156, 12, 149, 212, 89, 236, 74, 79,
+    44, 26, 233, 144, 148, 144, 55, 97, 155, 31, 31, 31, 238, 97, 94, 28, 216,
+    94, 141, 107, 89, 141, 107, 89, 233, 203, 24, 168, 178, 204, 122, 217, 232,
+    122, 217, 232, 122, 217, 232, 122, 217, 232, 122, 217, 232, 122, 217, 232,
+    122, 217, 232, 146, 136, 205, 223, 232, 233, 168, 178, 204, 50, 46, 104,
+    50, 46, 104, 127, 116, 194, 249, 101, 189, 252, 128, 201, 9, 61, 191, 253,
+    32, 3, 255, 156, 12, 160, 120, 92, 191, 142, 111, 160, 120, 100, 251, 209,
+    240, 191, 142, 111, 254, 121, 2, 28, 216, 94, 221, 136, 144, 131, 206, 12,
+    87, 21, 144, 127, 92, 69, 127, 92, 69, 127, 92, 69, 127, 92, 69, 253, 32,
+    3, 122, 217, 232, 122, 217, 232, 122, 217, 232, 122, 217, 232, 191, 142,
+    111, 198, 124, 78, 212, 192, 100, 100, 82, 126, 77, 76, 66, 96, 68, 117,
+    68, 60, 51, 174, 168, 186, 205, 152, 186, 212, 148, 88, 140, 140, 140, 120,
+    120, 120, 255, 227, 132, 85, 83, 82, 85, 83, 82, 75, 139, 166, 227, 46, 46,
+    75, 139, 166, 122, 217, 232, 122, 217, 232, 249, 75, 7, 0, 160, 170, 160,
+    87, 234, 22, 173, 254, 88, 95, 114, 99, 255, 107, 65, 75, 90, 65, 75, 90,
+    245, 197, 1, 146, 155, 187, 146, 155, 187, 168, 38, 47, 183, 53, 62, 255,
+    255, 255, 220, 220, 220, 39, 168, 96, 39, 94, 168, 242, 221, 100, 224, 100,
+    242, 197, 193, 216, 54, 183, 111, 54, 109, 183, 255, 236, 115, 239, 115,
+    255, 212, 208, 231, 238, 51, 53, 174, 129, 92, 3, 144, 201, 144, 148, 144,
+    191, 176, 124, 240, 240, 240, 255, 66, 152, 179, 132, 255, 0, 206, 180, 91,
+    186, 240, 92, 240, 91, 240, 91, 147, 255, 150, 181, 179, 132, 255, 174, 16,
+    176, 48, 225, 110, 179, 132, 255, 150, 164, 206, 211, 198, 111, 190, 223,
+    232, 141, 163, 181, 212, 192, 100, 231, 178, 28, 155, 214, 240, 233, 183,
+    128, 51, 84, 195, 205, 153, 73, 129, 56, 121, 129, 56, 121, 191, 142, 111,
+    191, 142, 111, 191, 142, 111, 190, 160, 140, 85, 114, 123, 116, 94, 97,
+    191, 142, 111, 160, 160, 160, 28, 216, 94, 108, 34, 35, 178, 114, 68, 120,
+    50, 50, 66, 84, 109, 84, 100, 63, 107, 68, 99, 73, 120, 17, 198, 134, 88,
+    191, 142, 111, 191, 142, 111, 127, 92, 69, 255, 29, 136, 211, 211, 211, 60,
+    20, 160, 78, 193, 227, 250, 249, 252, 224, 219, 236, 253, 227, 215, 165,
+    159, 153, 191, 142, 111, 202, 174, 165, 160, 187, 142, 254, 158, 35, 34,
+    221, 151, 249, 170, 236, 35, 200, 254, 92, 75, 118, 122, 217, 232, 61, 61,
+    61, 5, 5, 5, 5, 5, 5, 50, 50, 60, 191, 142, 111, 187, 68, 74, 49, 134, 114,
+    126, 134, 49, 134, 59, 49, 43, 86, 140, 121, 49, 134, 254, 121, 2, 26, 196,
+    84, 28, 216, 109, 224, 219, 236, 122, 217, 232, 122, 217, 232, 122, 217,
+    232, 122, 217, 232, 122, 217, 232, 122, 217, 232, 122, 217, 232, 182, 175,
+    130, 99, 150, 8, 107, 182, 0, 144, 148, 144, 122, 217, 232, 122, 217, 232,
+    114, 254, 2, 114, 254, 2, 0, 197, 208, 0, 197, 208, 122, 217, 232, 208, 0,
+    126, 208, 0, 126, 50, 107, 197, 122, 217, 232, 122, 217, 232, 122, 217,
+    232, 255, 126, 145, 60, 60, 60, 120, 110, 100, 120, 110, 100, 54, 83, 20,
+    122, 217, 232, 122, 217, 232, 186, 168, 84, 122, 217, 232, 122, 217, 232,
+    122, 217, 232, 122, 217, 232, 60, 60, 60, 122, 217, 232, 122, 217, 232,
+    150, 67, 22, 148, 158, 184, 165, 168, 26, 165, 168, 26, 87, 127, 220, 99,
+    99, 99, 233, 180, 90, 144, 148, 144, 248, 203, 233, 203, 248, 218, 160,
+    242, 255, 165, 168, 26, 255, 186, 212, 191, 142, 111, 76, 57, 44, 125, 61,
+    65, 30, 26, 84, 178, 104, 58, 172, 155, 110, 99, 99, 99, 122, 217, 232,
+    255, 150, 150, 122, 217, 232, 127, 127, 127, 127, 127, 127, 127, 127, 127,
+    127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
+    114, 81, 56, 254, 121, 2, 119, 105, 79, 119, 105, 79, 151, 107, 75, 151,
+    107, 75, 28, 216, 94, 122, 217, 232, 122, 217, 232, 122, 217, 232, 122,
+    217, 232, 122, 217, 232, 122, 217, 232, 122, 217, 232, 122, 217, 232, 122,
+    217, 232, 122, 217, 232, 122, 217, 232, 122, 217, 232, 122, 217, 232, 122,
+    217, 232, 122, 217, 232, 250, 100, 50, 250, 100, 50, 151, 107, 75, 151,
+    107, 75, 233, 207, 94, 128, 128, 128, 122, 217, 232, 122, 217, 232, 250,
+    250, 250, 235, 235, 249, 220, 210, 245, 210, 91, 77, 220, 12, 237, 220, 12,
+    237, 255, 76, 76, 255, 76, 76, 122, 217, 232, 117, 145, 73, 122, 234, 225,
+    122, 217, 232, 210, 140, 100, 145, 120, 120, 145, 120, 120, 122, 116, 218,
+    200, 120, 75, 200, 120, 75, 110, 105, 255, 122, 217, 232, 235, 125, 150,
+    149, 212, 89, 122, 217, 232, 122, 217, 232, 122, 217, 232, 108, 133, 140,
+    99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 99, 107, 182, 29, 107, 182, 29,
+    151, 79, 80, 200, 44, 28, 225, 128, 206, 21, 124, 212, 35, 205, 215, 200,
+    105, 230, 247, 228, 254, 255, 150, 150, 141, 137, 223, 208, 80, 80, 24,
+    203, 233, 128, 128, 128, 174, 24, 69, 115, 60, 40, 247, 228, 254, 151, 107,
+    75, 83, 46, 57, 91, 87, 167, 23, 33, 81, 53, 133, 103, 11, 67, 80, 40, 49,
+    60, 21, 13, 77, 195, 201, 215, 66, 84, 109, 84, 100, 63, 107, 68, 99, 185,
+    164, 23, 185, 194, 195, 150, 67, 22, 100, 90, 190, 142, 66, 66, 11, 80,
+    143, 91, 169, 169, 254, 121, 2, 208, 0, 126, 114, 254, 2, 0, 197, 208, 220,
+    12, 237, 255, 76, 76, 115, 173, 229, 115, 173, 229, 119, 101, 125, 141,
+    120, 168, 192, 202, 203, 200, 200, 200, 141, 107, 89, 210, 91, 77, 21, 124,
+    212, 149, 232, 87, 135, 196, 26, 127, 92, 69, 107, 182, 0, 177, 183, 161,
+    170, 48, 114, 237, 218, 244, 247, 228, 254, 122, 217, 232, 128, 128, 128,
+    128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128,
+    126, 102, 118, 245, 215, 196, 223, 255, 255, 164, 175, 175, 77, 176, 144,
+    185, 190, 20, 185, 190, 20, 185, 190, 20, 229, 65, 65, 30, 30, 36, 119, 22,
+    52, 23, 119, 79, 23, 54, 119, 119, 68, 23, 74, 23, 119, 78, 82, 109, 115,
+    69, 27, 160, 115, 80, 235, 200, 20, 240, 130, 160, 65, 75, 65, 210, 170,
+    215, 90, 125, 235, 211, 211, 211, 160, 90, 50, 26, 141, 204, 227, 227, 227,
+    106, 103, 96, 120, 114, 108, 122, 78, 21, 231, 178, 28, 2, 114, 206, 122,
+    122, 122, 122, 122, 122, 128, 128, 128, 128, 128, 128
+};
+
+uint8_t wallColors[] = {
+    0, 0, 0, 52, 52, 52, 88, 61, 46, 61, 58, 78, 73, 51, 36, 52, 52, 52, 91,
+    30, 30, 27, 31, 42, 31, 39, 26, 41, 28, 36, 74, 62, 12, 46, 56, 59, 75, 32,
+    11, 67, 37, 37, 15, 15, 15, 52, 43, 45, 88, 61, 46, 27, 31, 42, 31, 39, 26,
+    41, 28, 36, 15, 15, 15, 54, 89, 98, 113, 99, 99, 38, 38, 43, 53, 39, 41,
+    11, 35, 62, 21, 63, 70, 88, 61, 46, 81, 84, 101, 88, 23, 23, 28, 88, 23,
+    78, 87, 99, 86, 17, 40, 49, 47, 83, 69, 67, 41, 51, 51, 70, 87, 59, 55, 69,
+    67, 41, 49, 57, 49, 78, 79, 73, 85, 102, 103, 52, 50, 62, 71, 42, 44, 73,
+    66, 50, 52, 52, 52, 60, 59, 51, 48, 57, 47, 71, 77, 85, 52, 52, 52, 52, 52,
+    52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 40, 56, 50, 49, 48, 36,
+    43, 33, 32, 31, 40, 49, 48, 35, 52, 88, 61, 46, 1, 52, 20, 55, 39, 26, 39,
+    33, 26, 30, 80, 48, 53, 80, 30, 30, 80, 48, 30, 80, 48, 53, 80, 30, 30, 80,
+    48, 43, 42, 68, 30, 70, 80, 78, 105, 135, 52, 84, 12, 190, 204, 223, 64,
+    62, 80, 65, 65, 35, 20, 46, 104, 61, 13, 16, 63, 39, 26, 51, 47, 96, 64,
+    62, 80, 101, 51, 51, 77, 64, 34, 62, 38, 41, 48, 78, 93, 54, 63, 69, 138,
+    73, 38, 50, 15, 8, 115, 68, 124, 129, 114, 74, 62, 86, 123, 90, 121, 94,
+    135, 62, 61, 100, 96, 103, 32, 40, 45, 44, 41, 50, 72, 50, 77, 78, 50, 69,
+    36, 45, 44, 38, 49, 50, 32, 40, 45, 44, 41, 50, 72, 50, 77, 78, 50, 69, 36,
+    45, 44, 38, 49, 50, 97, 72, 51, 53, 53, 53, 138, 73, 38, 94, 25, 17, 125,
+    36, 122, 51, 35, 27, 50, 15, 8, 135, 58, 0, 65, 52, 15, 39, 42, 51, 89, 26,
+    27, 126, 123, 115, 8, 50, 19, 95, 21, 24, 17, 31, 65, 192, 173, 143, 114,
+    114, 131, 136, 119, 7, 8, 72, 3, 117, 132, 82, 100, 102, 114, 30, 118, 226,
+    93, 6, 102, 64, 40, 169, 39, 34, 180, 87, 94, 125, 6, 6, 6, 69, 72, 186,
+    130, 62, 16, 22, 123, 163, 40, 86, 151, 183, 75, 15, 83, 80, 100, 115, 65,
+    68, 119, 108, 81, 59, 67, 71, 222, 216, 202, 90, 112, 105, 62, 28, 87, 120,
+    120, 120, 120, 59, 19, 59, 59, 59, 229, 218, 161, 73, 59, 50, 81, 69, 62,
+    102, 75, 34, 103, 76, 36, 255, 145, 79, 221, 79, 255, 240, 240, 247, 79,
+    255, 89, 154, 83, 49, 107, 49, 154, 85, 89, 118, 49, 154, 68, 154, 49, 77,
+    49, 49, 154, 154, 148, 49, 255, 79, 79, 79, 102, 255, 250, 255, 79, 70, 68,
+    51, 84, 97, 84, 5, 5, 5, 59, 39, 22, 59, 39, 22, 163, 96, 0, 94, 163, 46,
+    117, 32, 59, 20, 11, 203, 74, 69, 88, 60, 30, 30, 111, 117, 135, 111, 117,
+    135, 25, 23, 54, 25, 23, 54, 74, 71, 129, 111, 117, 135, 25, 23, 54, 52,
+    52, 52, 38, 9, 66, 149, 80, 51, 82, 63, 80, 65, 61, 77, 64, 65, 92, 76, 53,
+    84, 144, 67, 52, 149, 48, 48, 111, 32, 36, 147, 48, 55, 97, 67, 51, 112,
+    80, 62, 88, 61, 46, 127, 94, 76, 143, 50, 123, 136, 120, 131, 219, 92, 143,
+    113, 64, 150, 74, 67, 60, 60, 78, 59, 0, 54, 21, 74, 97, 72, 40, 37, 35,
+    77, 63, 66, 111, 6, 6, 88, 67, 59, 88, 87, 80, 71, 71, 67, 76, 52, 60, 89,
+    48, 59, 158, 100, 64, 62, 45, 75, 57, 14, 12, 96, 72, 133, 67, 55, 80, 64,
+    37, 29, 70, 51, 91, 51, 18, 4, 57, 55, 52, 68, 68, 68, 148, 138, 74, 95,
+    137, 191, 160, 2, 75, 100, 55, 164, 0, 117, 101, 110, 90, 78, 47, 69, 75,
+    91, 67, 70, 60, 36, 39, 140, 75, 48, 127, 49, 44, 200, 44, 18, 24, 93, 66,
+    160, 87, 234, 6, 106, 255, 146, 95, 53, 5, 5, 5, 5, 5, 5, 63, 39, 26, 102,
+    102, 102, 61, 58, 78, 52, 43, 45, 81, 84, 101, 85, 102, 103, 52, 52, 52,
+    52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 52, 40, 56, 50, 49,
+    48, 36, 43, 33, 32, 31, 40, 49, 48, 35, 52, 88, 61, 46, 55, 39, 26, 39, 33,
+    26, 43, 42, 68, 30, 70, 80, 78, 105, 135, 51, 47, 96, 101, 51, 51, 62, 38,
+    41, 59, 39, 22, 59, 39, 22, 111, 117, 135, 25, 23, 54, 52, 52, 52, 149, 80,
+    51, 82, 63, 80, 65, 61, 77, 64, 65, 92, 76, 53, 84, 144, 67, 52, 149, 48,
+    48, 111, 32, 36, 147, 48, 55, 97, 67, 51, 112, 80, 62, 88, 61, 46, 127, 94,
+    76, 143, 50, 123, 136, 120, 131, 219, 92, 143, 113, 64, 150, 74, 67, 60,
+    60, 78, 59, 0, 54, 21, 74, 97, 72, 40, 37, 35, 77, 63, 66, 111, 6, 6, 88,
+    67, 59, 88, 87, 80, 71, 71, 67, 76, 52, 60, 89, 48, 59, 158, 100, 64, 62,
+    45, 75, 57, 14, 12, 96, 72, 133, 67, 55, 80, 64, 37, 29, 70, 51, 91, 51,
+    18, 4, 78, 110, 51, 78, 110, 51, 52, 52, 52, 181, 230, 29, 125, 100, 100,
+    125, 100, 100, 6, 6, 34, 105, 51, 108, 75, 30, 15, 91, 108, 130, 91, 108,
+    130, 55, 25, 33, 60, 55, 145, 10, 5, 50, 30, 105, 75, 5, 45, 55, 20, 25,
+    35, 15, 10, 50, 153, 164, 187, 27, 31, 42, 31, 39, 26, 41, 28, 36, 74, 62,
+    12, 46, 56, 59, 75, 32, 11, 15, 15, 15, 67, 37, 37, 11, 35, 62, 21, 63, 70,
+    100, 40, 1, 92, 30, 72, 42, 81, 1, 1, 81, 109, 56, 22, 97, 52, 52, 52, 100,
+    65, 130, 120, 75, 75, 52, 52, 52, 0, 255, 0, 80, 58, 40, 118, 100, 10, 14,
+    54, 34, 120, 65, 80, 32, 38, 32, 105, 85, 108, 45, 62, 118, 80, 45, 25, 13,
+    70, 102, 73, 93, 116, 53, 52, 48, 60, 57, 54, 61, 39, 10, 116, 89, 14, 1,
+    57, 103, 61, 61, 61
+};
+
+uint8_t paintColors[] = {
+    0, 0, 0, 255, 0, 0, 255, 127, 0, 255, 255, 0, 127, 255, 0, 0, 255, 0, 0,
+    255, 127, 0, 255, 255, 0, 127, 255, 0, 0, 255, 127, 0, 255, 255, 0, 255,
+    255, 0, 127, 255, 0, 0, 255, 127, 0, 255, 255, 0, 127, 255, 0, 0, 255, 0,
+    0, 255, 127, 0, 255, 255, 0, 127, 255, 0, 0, 255, 127, 0, 255, 255, 0, 255,
+    255, 0, 127, 75, 75, 75, 255, 255, 255, 175, 175, 175, 255, 178, 125, 25,
+    25, 25, 255, 255, 255, 255, 255, 255
+};
+// clang-format on
+
+namespace Colors
+{
+uint8_t water[] = {0, 12, 255};
+uint8_t lava[] = {255, 30, 0};
+uint8_t honey[] = {255, 172, 0};
+uint8_t shimmer[] = {155, 112, 233};
+
+uint8_t space[] = {55, 58, 248};
+uint8_t surface[] = {150, 180, 251};
+uint8_t surfaceFlat[] = {132, 170, 248};
+uint8_t underground[] = {84, 57, 42};
+uint8_t cavern[] = {72, 64, 57};
+uint8_t underworld[] = {51, 0, 0};
+
+uint8_t black[] = {0, 0, 0};
+uint8_t red[] = {255, 0, 0};
+uint8_t blue[] = {0, 0, 255};
+uint8_t green[] = {0, 255, 0};
+uint8_t yellow[] = {255, 255, 0};
+} // namespace Colors
+
+} // namespace
+
+inline uint8_t roundToUint8(double val)
+{
+    return std::clamp<int>(std::lround(val), 0, UINT8_MAX);
+}
+
+Color::Color(uint8_t *rgb)
+{
+    set(rgb[0], rgb[1], rgb[2]);
+}
+
+void Color::set(uint8_t r, uint8_t g, uint8_t b)
+{
+    abgr = (0xff << 24) | (b << 16) | (g << 8) | r;
+}
+
+uint8_t Color::r() const
+{
+    return abgr & 0xff;
+}
+
+uint8_t Color::g() const
+{
+    return (abgr >> 8) & 0xff;
+}
+
+uint8_t Color::b() const
+{
+    return (abgr >> 16) & 0xff;
+}
+
+void Color::blend(Color tint, double strength)
+{
+    double base = 1 - strength;
+    set(base * r() + strength * tint.r(),
+        base * g() + strength * tint.g(),
+        base * b() + strength * tint.b());
+}
+
+void Color::ditherBlend(
+    Color tint,
+    double strength,
+    int x,
+    std::vector<double> &errCur,
+    std::vector<double> &errNext)
+{
+    double target[] = {
+        errCur[3 * x] + r() + strength * (tint.r() - r()),
+        errCur[3 * x + 1] + g() + strength * (tint.g() - g()),
+        errCur[3 * x + 2] + b() + strength * (tint.b() - b())};
+    uint8_t quant[] = {
+        roundToUint8(target[0]),
+        roundToUint8(target[1]),
+        roundToUint8(target[2])};
+    for (int i = 0; i < 3; ++i) {
+        double residule = target[i] - quant[i];
+        errCur[3 * (x + 1) + i] += 7 * residule / 16;
+        if (x > 0) {
+            errNext[3 * (x - 1) + i] += 3 * residule / 16;
+        }
+        errNext[3 * (x) + i] += 5 * residule / 16;
+        errNext[3 * (x + 1) + i] += residule / 16;
+    }
+    set(quant[0], quant[1], quant[2]);
+}
+
+void Color::hueBlend(Color tint)
+{
+    uint8_t rgbMax = std::max({r(), g(), b()});
+    uint8_t rgbMin = std::min({r(), g(), b()});
+    double v = rgbMax / 255.0;
+    double s = rgbMax == 0 ? 0 : (v - (rgbMin / 255.0)) / v;
+
+    uint8_t primary;
+    double secondary;
+    rgbMax = std::max({tint.r(), tint.g(), tint.b()});
+    rgbMin = std::min({tint.r(), tint.g(), tint.b()});
+    if (rgbMax == 0 || rgbMax == rgbMin) {
+        primary = 0;
+        secondary = 0;
+        s = 0;
+    } else {
+        double fMax = rgbMax / 255.0;
+        double divisor = fMax - (rgbMin / 255.0);
+        uint8_t r = tint.r();
+        uint8_t g = tint.g();
+        uint8_t b = tint.b();
+        if (r == rgbMax) {
+            if (g == rgbMin) {
+                primary = 5;
+                secondary = (fMax - (b / 255.0)) / divisor;
+            } else {
+                primary = 0;
+                secondary = 1 - ((fMax - (g / 255.0)) / divisor);
+            }
+        } else if (g == rgbMax) {
+            if (b == rgbMin) {
+                primary = 1;
+                secondary = (fMax - (r / 255.0)) / divisor;
+            } else {
+                primary = 2;
+                secondary = 1 - ((fMax - (b / 255.0)) / divisor);
+            }
+        } else if (b == rgbMax && r == rgbMin) {
+            primary = 3;
+            secondary = (fMax - (g / 255.0)) / divisor;
+        } else {
+            primary = 4;
+            secondary = 1 - ((fMax - (r / 255.0)) / divisor);
+        }
+    }
+    double x = (1.0 - s) * v;
+    double y = (1.0 - (s * secondary)) * v;
+    double z = (1.0 - (s * (1.0 - secondary))) * v;
+    switch (primary) {
+    case 0:
+        set((v * 255.0) + 0.5, (z * 255.0) + 0.5, (x * 255.0) + 0.5);
+        break;
+    case 1:
+        set((y * 255.0) + 0.5, (v * 255.0) + 0.5, (x * 255.0) + 0.5);
+        break;
+    case 2:
+        set((x * 255.0) + 0.5, (v * 255.0) + 0.5, (z * 255.0) + 0.5);
+        break;
+    case 3:
+        set((x * 255.0) + 0.5, (y * 255.0) + 0.5, (v * 255.0) + 0.5);
+        break;
+    case 4:
+        set((z * 255.0) + 0.5, (x * 255.0) + 0.5, (v * 255.0) + 0.5);
+        break;
+    case 5:
+        set((v * 255.0) + 0.5, (x * 255.0) + 0.5, (y * 255.0) + 0.5);
+        break;
+    }
+    blend(tint);
+}
+
+Color getLayerColor(
+    int x,
+    int y,
+    std::vector<double> &errCur,
+    std::vector<double> &errNext,
+    World &world)
+{
+    if (y < world.undergroundLevel) {
+        if (world.seedRemix) {
+            return Colors::black;
+        } else if (world.version < 315) {
+            return Colors::surfaceFlat;
+        }
+        Color color{Colors::space};
+        color.ditherBlend(
+            Colors::surface,
+            static_cast<double>(y) / world.undergroundLevel,
+            x,
+            errCur,
+            errNext);
+        return color;
+    } else if (y < world.cavernLevel) {
+        return Colors::underground;
+    } else if (y < world.height - 230) {
+        return Colors::cavern;
+    } else {
+        return Colors::underworld;
+    }
+}
+
+Color getTileColor(
+    int x,
+    int y,
+    std::vector<double> &errCur,
+    std::vector<double> &errNext,
+    World &world)
+{
+    Color color = getLayerColor(x, y, errCur, errNext, world);
+    Tile &tile = world.getTile(x, y);
+    if (tile.wallId != 0) {
+        Color wallColor{wallColors + 3 * tile.wallId};
+        if (tile.wallPaint != 0) {
+            wallColor.hueBlend(paintColors + 3 * tile.wallPaint);
+        }
+        if (tile.echoCoatWall) {
+            color.blend(wallColor, 0.1);
+        } else {
+            color = wallColor;
+        }
+    }
+    switch (tile.liquid) {
+    case Liquid::water:
+        color.blend(Colors::water, 0.85);
+        break;
+    case Liquid::lava:
+        color = Colors::lava;
+        break;
+    case Liquid::honey:
+        color = Colors::honey;
+        break;
+    case Liquid::shimmer:
+        color = Colors::shimmer;
+        break;
+    default:
+        break;
+    }
+    if (tile.blockId != -1) {
+        Color blockColor{blockColors + 3 * tile.blockId};
+        if (tile.actuated) {
+            blockColor.blend(Colors::black);
+        }
+        if (tile.blockPaint != 0) {
+            blockColor.hueBlend(paintColors + 3 * tile.blockPaint);
+        }
+        if (tile.echoCoatBlock) {
+            color.blend(blockColor, 0.15);
+        } else {
+            color = blockColor;
+        }
+    }
+    if (tile.wireRed) {
+        color.blend(Colors::red);
+    }
+    if (tile.wireBlue) {
+        color.blend(Colors::blue);
+    }
+    if (tile.wireGreen) {
+        color.blend(Colors::green);
+    }
+    if (tile.wireYellow) {
+        color.blend(Colors::yellow);
+    }
+    return color;
+}
diff --git a/wasm/src/TileColor.h b/wasm/src/TileColor.h
new file mode 100644
index 0000000..a57e610
--- /dev/null
+++ b/wasm/src/TileColor.h
@@ -0,0 +1,39 @@
+#ifndef TILECOLOR_H
+#define TILECOLOR_H
+
+#include <cstdint>
+#include <vector>
+
+class World;
+
+class Color
+{
+public:
+    Color() = default;
+    Color(uint8_t *rgb);
+
+    void set(uint8_t r, uint8_t g, uint8_t b);
+    uint8_t r() const;
+    uint8_t g() const;
+    uint8_t b() const;
+
+    void blend(Color tint, double strength = 0.3);
+    void ditherBlend(
+        Color tint,
+        double strength,
+        int x,
+        std::vector<double> &errCur,
+        std::vector<double> &errNext);
+    void hueBlend(Color tint);
+
+    uint32_t abgr;
+};
+
+Color getTileColor(
+    int x,
+    int y,
+    std::vector<double> &errCur,
+    std::vector<double> &errNext,
+    World &world);
+
+#endif // TILECOLOR_H
diff --git a/wasm/src/World.cpp b/wasm/src/World.cpp
new file mode 100644
index 0000000..c9fd6af
--- /dev/null
+++ b/wasm/src/World.cpp
@@ -0,0 +1,12 @@
+#include "World.h"
+
+void World::initTiles()
+{
+    tiles.clear();
+    tiles.resize(width * height);
+}
+
+Tile &World::getTile(int x, int y)
+{
+    return tiles[y + x * height];
+}
diff --git a/wasm/src/World.h b/wasm/src/World.h
new file mode 100644
index 0000000..b3b005c
--- /dev/null
+++ b/wasm/src/World.h
@@ -0,0 +1,277 @@
+#ifndef WORLD_H
+#define WORLD_H
+
+#include "Tile.h"
+#include <array>
+#include <string>
+#include <vector>
+
+struct Point {
+    int x;
+    int y;
+};
+
+struct Item {
+    int id;
+    int stack;
+    int prefix;
+};
+
+struct Chest {
+    int x;
+    int y;
+    std::string name;
+    std::vector<Item> items;
+};
+
+struct Sign {
+    int x;
+    int y;
+    std::string text;
+};
+
+struct NPC {
+    int id;
+    std::string type;
+    std::string name;
+    double x;
+    double y;
+    bool isHomeless;
+    int homeX;
+    int homeY;
+    int variation;
+    bool homelessDespawn;
+};
+
+struct TileEntity {
+    int id;
+    int type;
+    int x;
+    int y;
+    int sensorType;
+    bool sensorActive;
+    std::vector<Item> items;
+    std::vector<Item> dyes;
+};
+
+struct CreativePowers {
+    bool freezeTime;
+    double timeRate;
+    bool freezeRainStatus;
+    bool freezeWindStatus;
+    double difficulty;
+    bool freezeBiomeSpread;
+};
+
+class World
+{
+    std::vector<Tile> tiles;
+
+public:
+    void initTiles();
+    Tile &getTile(int x, int y);
+
+    int version;
+    int revision;
+    bool isFavorite;
+    std::vector<bool> framedTiles;
+
+    std::string name;
+    std::string seed;
+    std::string generatorVersion;
+    std::string guid;
+    int id;
+    int left;
+    int right;
+    int top;
+    int bottom;
+    int height;
+    int width;
+    int gameMode;
+    bool seedDrunkWorld;
+    bool seedForTheWorthy;
+    bool seedCelebrationmk10;
+    bool seedTheConstant;
+    bool seedNotTheBees;
+    bool seedRemix;
+    bool seedNoTraps;
+    bool seedZenith;
+    bool seedSkyblock;
+    std::string creationTime;
+    std::string lastPlayed;
+
+    int moonType;
+    std::array<int, 3> treeStyleCoords;
+    std::array<int, 4> treeStyles;
+    std::array<int, 3> caveStyleCoords;
+    std::array<int, 4> caveStyles;
+    int iceStyle;
+    int jungleStyle;
+    int underworldStyle;
+    std::array<int, 2> spawn;
+    double undergroundLevel;
+    double cavernLevel;
+    double gameTime;
+    bool isDay;
+    int moonPhase;
+    bool bloodMoon;
+    bool eclipse;
+    std::array<int, 2> dungeon;
+    bool isCrimson;
+
+    bool downedEyeOfCthulu;
+    bool downedEaterOfWorlds;
+    bool downedSkeletron;
+    bool downedQueenBee;
+    bool downedTheDestroyer;
+    bool downedTheTwins;
+    bool downedSkeletronPrime;
+    bool downedAnyHardmodeBoss;
+    bool downedPlantera;
+    bool downedGolem;
+    bool downedSlimeKing;
+    bool savedGoblinTinkerer;
+    bool savedWizard;
+    bool savedMechanic;
+    bool defeatedGoblinInvasion;
+    bool downedClown;
+    bool defeatedFrostLegion;
+    bool defeatedPirates;
+
+    bool brokeAShadowOrb;
+    bool meteorSpawned;
+    int shadowOrbsBroken;
+    int altarsSmashed;
+    bool hardMode;
+    bool partyOfDoom;
+    int goblinInvasionDelay;
+    int goblinInvasionSize;
+    int goblinInvasionType;
+    double goblinInvasionX;
+    double slimeRainTime;
+    int sundialCooldown;
+    bool raining;
+    int rainTimeLeft;
+    double maxRain;
+    int cobaltVariant;
+    int mythrilVariant;
+    int adamantiteVariant;
+    int forestStyle1;
+    int corruptionStyle;
+    int undergroundJungleStyle;
+    int snowStyle;
+    int hallowStyle;
+    int crimsonStyle;
+    int desertStyle;
+    int oceanStyle;
+    int cloudBackground;
+    int numberOfClouds;
+    double windSpeed;
+
+    std::vector<std::string> anglersFinishedDailyQuest;
+    bool savedAngler;
+    int anglerQuest;
+    bool savedStylist;
+    bool savedTaxCollector;
+    bool savedGolfer;
+    int invasionStartSize;
+    int cultistDelay;
+    std::vector<int> enemyKillTallies;
+    std::vector<int> claimableBanners;
+    bool fastForwardTimeToDawn;
+
+    bool downedFishron;
+    bool downedMartians;
+    bool downedLunaticCultist;
+    bool downedMoonlord;
+    bool downedHalloweenPumpking;
+    bool downedHalloweenMourningWood;
+    bool downedChristmasIceQueen;
+    bool downedChristmasSantaNK1;
+    bool downedChristmasEverscream;
+    bool downedTowerSolar;
+    bool downedTowerVortex;
+    bool downedTowerNebula;
+    bool downedTowerStardust;
+    bool towerActiveSolar;
+    bool towerActiveVortex;
+    bool towerActiveNebula;
+    bool towerActiveStardust;
+    bool lunarApocalypseIsUp;
+
+    bool partyManual;
+    bool partyGenuine;
+    int partyCooldown;
+    std::vector<int> partyingNPCs;
+    bool sandstormActive;
+    int sandstormTimeLeft;
+    double sandstormSeverity;
+    double sandstormIntendedSeverity;
+    bool savedBartender;
+    bool downedInvasionTier1;
+    bool downedInvasionTier2;
+    bool downedInvasionTier3;
+    int mushroomStyle;
+    int underworldStyle2;
+    int forestStyle2;
+    int forestStyle3;
+    int forestStyle4;
+    bool combatBookUsed;
+    int lanternNightCooldown;
+    bool lanternNightGenuine;
+    bool lanternNightManual;
+    bool lanternNightNextIsGenuine;
+    std::vector<int> treeTopVariations;
+    bool forceHalloween;
+    bool forceChristmas;
+    int copperVariant;
+    int ironVariant;
+    int silverVariant;
+    int goldVariant;
+    bool boughtCat;
+    bool boughtDog;
+    bool boughtBunny;
+
+    bool downedEmpressOfLight;
+    bool downedQueenSlime;
+    bool downedDeerclops;
+    bool unlockedNerdySlime;
+    bool unlockedMerchant;
+    bool unlockedDemolitionist;
+    bool unlockedPartyGirl;
+    bool unlockedDyeTrader;
+    bool unlockedTruffle;
+    bool unlockedArmsDealer;
+    bool unlockedNurse;
+    bool unlockedPrincess;
+    bool combatBookVolumeTwoUsed;
+    bool peddlersSatchelUsed;
+    bool unlockedCoolSlime;
+    bool unlockedElderSlime;
+    bool unlockedClumsySlime;
+    bool unlockedDivaSlime;
+    bool unlockedSurlySlime;
+    bool unlockedMysticSlime;
+    bool unlockedSquireSlime;
+    bool fastForwardTimeToDusk;
+    int moondialCooldown;
+    bool seedEndlessHalloween;
+    bool seedEndlessChristmas;
+    bool seedVampirism;
+    bool seedInfectedWorld;
+    int meteorShowerCount;
+    int coinRain;
+    bool seedTeamBasedSpawns;
+    std::vector<Point> extraSpawnPoints;
+    bool seedDualDungeons;
+    std::string worldGenManifest;
+
+    std::vector<Chest> chests;
+    std::vector<Sign> signs;
+    std::vector<int> shimmeredNPCs;
+    std::vector<NPC> npcs;
+    std::vector<TileEntity> tileEntities;
+    CreativePowers creative;
+};
+
+#endif // WORLD_H
diff --git a/wasm/src/WorldLoader.cpp b/wasm/src/WorldLoader.cpp
new file mode 100644
index 0000000..3aee69a
--- /dev/null
+++ b/wasm/src/WorldLoader.cpp
@@ -0,0 +1,715 @@
+#include "WorldLoader.h"
+
+#include "Reader.h"
+#include <chrono>
+#include <format>
+
+bool isValidWorldSize(const World &world)
+{
+    return world.width > 0 && world.height > 0 && world.width < 33600 &&
+           world.height < 9600;
+}
+
+std::string parseBinaryTime(uint64_t ticks)
+{
+    uint64_t ms = (ticks & 0x3fffffffffffffffull) / 10000 - 62135596800000ull;
+    auto time = std::chrono::sys_time{std::chrono::milliseconds{ms}};
+    return std::format("{:%e %B %Y}", time);
+}
+
+void readProperties(Reader &r, World &world)
+{
+    world.version = r.getUint32();
+    r.skipBytes(8);
+    world.revision = r.getUint32();
+    world.isFavorite = r.getBool();
+    r.skipBytes(7);
+    r.skipBytes(4 * r.getUint16());
+    world.framedTiles = r.getBitVec();
+
+    world.name = r.getString();
+    if (world.version >= 179) {
+        world.seed = world.version == 179 ? std::to_string(r.getUint32())
+                                          : r.getString();
+        world.generatorVersion = std::to_string(r.getUint64());
+    }
+    if (world.version >= 181) {
+        for (int i = 0; i < 16; ++i) {
+            if (i == 4 || i == 6 || i == 8 || i == 10) {
+                world.guid += '-';
+            }
+            world.guid += std::format("{:02x}", r.getUint8());
+        }
+    }
+    world.id = r.getUint32();
+    world.left = r.getUint32();
+    world.right = r.getUint32();
+    world.top = r.getUint32();
+    world.bottom = r.getUint32();
+    world.height = r.getUint32();
+    world.width = r.getUint32();
+    if (!isValidWorldSize(world)) {
+        return;
+    }
+    if (world.version >= 209) {
+        world.gameMode = r.getUint32();
+        if (world.version >= 222) {
+            world.seedDrunkWorld = r.getBool();
+        }
+        if (world.version >= 227) {
+            world.seedForTheWorthy = r.getBool();
+        }
+        if (world.version >= 238) {
+            world.seedCelebrationmk10 = r.getBool();
+        }
+        if (world.version >= 239) {
+            world.seedTheConstant = r.getBool();
+        }
+        if (world.version >= 241) {
+            world.seedNotTheBees = r.getBool();
+        }
+        if (world.version >= 249) {
+            world.seedRemix = r.getBool();
+        }
+        if (world.version >= 266) {
+            world.seedNoTraps = r.getBool();
+        }
+        world.seedZenith = world.version < 267
+                               ? world.seedDrunkWorld && world.seedRemix
+                               : r.getBool();
+        if (world.version >= 302) {
+            world.seedSkyblock = r.getBool();
+        }
+    } else if (world.version >= 112) {
+        world.gameMode = r.getBool() ? 1 : 0;
+    }
+    if (world.version >= 141) {
+        world.creationTime = parseBinaryTime(r.getUint64());
+    }
+    if (world.version >= 284) {
+        world.lastPlayed = parseBinaryTime(r.getUint64());
+    }
+
+    world.moonType = r.getUint8();
+    for (auto &val : world.treeStyleCoords) {
+        val = r.getUint32();
+    }
+    for (auto &val : world.treeStyles) {
+        val = r.getUint32();
+    }
+    for (auto &val : world.caveStyleCoords) {
+        val = r.getUint32();
+    }
+    for (auto &val : world.caveStyles) {
+        val = r.getUint32();
+    }
+    world.iceStyle = r.getUint32();
+    world.jungleStyle = r.getUint32();
+    world.underworldStyle = r.getUint32();
+    for (auto &val : world.spawn) {
+        val = r.getUint32();
+    }
+    world.undergroundLevel = r.getFloat64();
+    world.cavernLevel = r.getFloat64();
+    world.gameTime = r.getFloat64();
+    world.isDay = r.getBool();
+    world.moonPhase = r.getUint32();
+    world.bloodMoon = r.getBool();
+    world.eclipse = r.getBool();
+    for (auto &val : world.dungeon) {
+        val = r.getUint32();
+    }
+    world.isCrimson = r.getBool();
+
+    world.downedEyeOfCthulu = r.getBool();
+    world.downedEaterOfWorlds = r.getBool();
+    world.downedSkeletron = r.getBool();
+    world.downedQueenBee = r.getBool();
+    world.downedTheDestroyer = r.getBool();
+    world.downedTheTwins = r.getBool();
+    world.downedSkeletronPrime = r.getBool();
+    world.downedAnyHardmodeBoss = r.getBool();
+    world.downedPlantera = r.getBool();
+    world.downedGolem = r.getBool();
+    if (world.version >= 118) {
+        world.downedSlimeKing = r.getBool();
+    }
+    world.savedGoblinTinkerer = r.getBool();
+    world.savedWizard = r.getBool();
+    world.savedMechanic = r.getBool();
+    world.defeatedGoblinInvasion = r.getBool();
+    world.downedClown = r.getBool();
+    world.defeatedFrostLegion = r.getBool();
+    world.defeatedPirates = r.getBool();
+
+    world.brokeAShadowOrb = r.getBool();
+    world.meteorSpawned = r.getBool();
+    world.shadowOrbsBroken = r.getUint8();
+    world.altarsSmashed = r.getUint32();
+    world.hardMode = r.getBool();
+    if (world.version >= 257) {
+        world.partyOfDoom = r.getBool();
+    }
+    world.goblinInvasionDelay = r.getUint32();
+    world.goblinInvasionSize = r.getUint32();
+    world.goblinInvasionType = r.getUint32();
+    world.goblinInvasionX = r.getFloat64();
+    if (world.version >= 118) {
+        world.slimeRainTime = r.getFloat64();
+    }
+    if (world.version >= 113) {
+        world.sundialCooldown = r.getUint8();
+    }
+    world.raining = r.getBool();
+    world.rainTimeLeft = r.getUint32();
+    world.maxRain = r.getFloat32();
+    world.cobaltVariant = r.getUint32();
+    world.mythrilVariant = r.getUint32();
+    world.adamantiteVariant = r.getUint32();
+    world.forestStyle1 = r.getUint8();
+    world.corruptionStyle = r.getUint8();
+    world.undergroundJungleStyle = r.getUint8();
+    world.snowStyle = r.getUint8();
+    world.hallowStyle = r.getUint8();
+    world.crimsonStyle = r.getUint8();
+    world.desertStyle = r.getUint8();
+    world.oceanStyle = r.getUint8();
+    world.cloudBackground = r.getUint32();
+    world.numberOfClouds = r.getUint16();
+    world.windSpeed = r.getFloat32();
+    if (world.version < 95) {
+        return;
+    }
+
+    for (int i = r.getUint32(); i > 0; --i) {
+        world.anglersFinishedDailyQuest.push_back(r.getString());
+    }
+    world.savedAngler = r.getBool();
+    if (world.version < 101) {
+        return;
+    }
+    world.anglerQuest = r.getUint32();
+    if (world.version < 104) {
+        return;
+    }
+    world.savedStylist = r.getBool();
+    world.savedTaxCollector = r.getBool();
+    if (world.version >= 201) {
+        world.savedGolfer = r.getBool();
+    }
+    world.invasionStartSize = r.getUint32();
+    world.cultistDelay = r.getUint32();
+    for (int i = r.getUint16(); i > 0; --i) {
+        world.enemyKillTallies.push_back(r.getUint32());
+    }
+    if (world.version >= 289) {
+        for (int i = r.getUint16(); i > 0; --i) {
+            world.claimableBanners.push_back(r.getUint16());
+        }
+    }
+    world.fastForwardTimeToDawn = r.getBool();
+
+    world.downedFishron = r.getBool();
+    world.downedMartians = r.getBool();
+    world.downedLunaticCultist = r.getBool();
+    world.downedMoonlord = r.getBool();
+    world.downedHalloweenPumpking = r.getBool();
+    world.downedHalloweenMourningWood = r.getBool();
+    world.downedChristmasIceQueen = r.getBool();
+    world.downedChristmasSantaNK1 = r.getBool();
+    world.downedChristmasEverscream = r.getBool();
+    world.downedTowerSolar = r.getBool();
+    world.downedTowerVortex = r.getBool();
+    world.downedTowerNebula = r.getBool();
+    world.downedTowerStardust = r.getBool();
+    world.towerActiveSolar = r.getBool();
+    world.towerActiveVortex = r.getBool();
+    world.towerActiveNebula = r.getBool();
+    world.towerActiveStardust = r.getBool();
+    world.lunarApocalypseIsUp = r.getBool();
+
+    if (world.version >= 170) {
+        world.partyManual = r.getBool();
+        world.partyGenuine = r.getBool();
+        world.partyCooldown = r.getUint32();
+        for (int i = r.getUint32(); i > 0; --i) {
+            world.partyingNPCs.push_back(r.getUint32());
+        }
+    }
+    if (world.version >= 174) {
+        world.sandstormActive = r.getBool();
+        world.sandstormTimeLeft = r.getUint32();
+        world.sandstormSeverity = r.getFloat32();
+        world.sandstormIntendedSeverity = r.getFloat32();
+    }
+    if (world.version >= 178) {
+        world.savedBartender = r.getBool();
+        world.downedInvasionTier1 = r.getBool();
+        world.downedInvasionTier2 = r.getBool();
+        world.downedInvasionTier3 = r.getBool();
+    }
+    if (world.version < 225) {
+        return;
+    }
+    world.mushroomStyle = r.getUint8();
+    world.underworldStyle2 = r.getUint8();
+    world.forestStyle2 = r.getUint8();
+    world.forestStyle3 = r.getUint8();
+    world.forestStyle4 = r.getUint8();
+    world.combatBookUsed = r.getBool();
+    world.lanternNightCooldown = r.getUint32();
+    world.lanternNightGenuine = r.getBool();
+    world.lanternNightManual = r.getBool();
+    world.lanternNightNextIsGenuine = r.getBool();
+    for (int i = r.getUint32(); i > 0; --i) {
+        world.treeTopVariations.push_back(r.getUint32());
+    }
+    world.forceHalloween = r.getBool();
+    world.forceChristmas = r.getBool();
+    world.copperVariant = r.getUint32();
+    world.ironVariant = r.getUint32();
+    world.silverVariant = r.getUint32();
+    world.goldVariant = r.getUint32();
+    world.boughtCat = r.getBool();
+    world.boughtDog = r.getBool();
+    world.boughtBunny = r.getBool();
+
+    if (world.version >= 223) {
+        world.downedEmpressOfLight = r.getBool();
+        world.downedQueenSlime = r.getBool();
+    }
+    if (world.version >= 240) {
+        world.downedDeerclops = r.getBool();
+    }
+    if (world.version < 269) {
+        return;
+    }
+    world.unlockedNerdySlime = r.getBool();
+    world.unlockedMerchant = r.getBool();
+    world.unlockedDemolitionist = r.getBool();
+    world.unlockedPartyGirl = r.getBool();
+    world.unlockedDyeTrader = r.getBool();
+    world.unlockedTruffle = r.getBool();
+    world.unlockedArmsDealer = r.getBool();
+    world.unlockedNurse = r.getBool();
+    world.unlockedPrincess = r.getBool();
+    world.combatBookVolumeTwoUsed = r.getBool();
+    world.peddlersSatchelUsed = r.getBool();
+    world.unlockedCoolSlime = r.getBool();
+    world.unlockedElderSlime = r.getBool();
+    world.unlockedClumsySlime = r.getBool();
+    world.unlockedDivaSlime = r.getBool();
+    world.unlockedSurlySlime = r.getBool();
+    world.unlockedMysticSlime = r.getBool();
+    world.unlockedSquireSlime = r.getBool();
+    world.fastForwardTimeToDusk = r.getBool();
+    world.moondialCooldown = r.getUint8();
+    if (world.version < 315) {
+        return;
+    }
+    world.seedEndlessHalloween = r.getBool();
+    world.seedEndlessChristmas = r.getBool();
+    world.seedVampirism = r.getBool();
+    world.seedInfectedWorld = r.getBool();
+    world.meteorShowerCount = r.getUint32();
+    world.coinRain = r.getUint32();
+    world.seedTeamBasedSpawns = r.getBool();
+    for (int i = r.getUint8(); i > 0; --i) {
+        int x = r.getUint16();
+        int y = r.getUint16();
+        world.extraSpawnPoints.push_back({x, y});
+    }
+    world.seedDualDungeons = r.getBool();
+    world.worldGenManifest = r.getString();
+}
+
+void readTiles(Reader &r, World &world)
+{
+    world.initTiles();
+    for (int x = 0; x < world.width; ++x) {
+        for (int y = 0, rle = 0; y < world.height; ++y) {
+            Tile &tile = world.getTile(x, y);
+            if (rle > 0) {
+                tile = world.getTile(x, y - 1);
+                --rle;
+                continue;
+            }
+            std::array flags{0, 0, 0, 0};
+            for (auto &flag : flags) {
+                flag = r.getUint8();
+                if ((flag & 0x01) == 0) {
+                    break;
+                }
+            }
+            if ((flags[0] & 0x02) == 0) {
+                tile.blockId = -1;
+            } else {
+                if ((flags[0] & 0x20) == 0) {
+                    tile.blockId = r.getUint8();
+                } else {
+                    tile.blockId = r.getUint16();
+                }
+                if (world.framedTiles[tile.blockId]) {
+                    tile.frameX = static_cast<int16_t>(r.getUint16());
+                    tile.frameY = static_cast<int16_t>(r.getUint16());
+                }
+                if ((flags[2] & 0x08) != 0) {
+                    tile.blockPaint = r.getUint8();
+                }
+                tile.slope = static_cast<Slope>((flags[1] >> 4) & 0x07);
+            }
+            if ((flags[0] & 0x04) == 0) {
+                tile.wallId = 0;
+            } else {
+                tile.wallId = r.getUint8();
+                if ((flags[2] & 0x10) != 0) {
+                    tile.wallPaint = r.getUint8();
+                }
+            }
+            if ((flags[0] & 0x18) == 0x08) {
+                tile.liquid =
+                    (flags[2] & 0x80) == 0 ? Liquid::water : Liquid::shimmer;
+            } else if ((flags[0] & 0x18) == 0x10) {
+                tile.liquid = Liquid::lava;
+            } else if ((flags[0] & 0x18) == 0x18) {
+                tile.liquid = Liquid::honey;
+            }
+            if (tile.liquid != Liquid::none) {
+                tile.liquidAmount = r.getUint8();
+            }
+            if ((flags[2] & 0x40) != 0) {
+                tile.wallId |= r.getUint8() << 8;
+            }
+            tile.wireRed = (flags[1] & 0x02) != 0;
+            tile.wireBlue = (flags[1] & 0x04) != 0;
+            tile.wireGreen = (flags[1] & 0x08) != 0;
+            tile.wireYellow = (flags[2] & 0x20) != 0;
+            tile.actuator = (flags[2] & 0x02) != 0;
+            tile.actuated = (flags[2] & 0x04) != 0;
+            tile.echoCoatBlock = (flags[3] & 0x02) != 0;
+            tile.echoCoatWall = (flags[3] & 0x04) != 0;
+            tile.illuminantBlock = (flags[3] & 0x08) != 0;
+            tile.illuminantWall = (flags[3] & 0x10) != 0;
+            if ((flags[0] & 0x40) != 0) {
+                rle = r.getUint8();
+            } else if ((flags[0] & 0x80) != 0) {
+                rle = r.getUint16();
+            }
+        }
+    }
+}
+
+void readChests(Reader &r, World &world)
+{
+    world.chests.resize(r.getUint16());
+    int chestSlots = world.version >= 294 ? 0 : r.getUint16();
+    for (Chest &chest : world.chests) {
+        chest.x = r.getUint32();
+        chest.y = r.getUint32();
+        chest.name = r.getString();
+        if (world.version >= 294) {
+            chestSlots = r.getUint32();
+        }
+        for (int slot = 0; slot < chestSlots; ++slot) {
+            int stack = r.getUint16();
+            if (stack > 0) {
+                chest.items.resize(slot + 1);
+                Item &item = chest.items[slot];
+                item.id = r.getUint32();
+                item.stack = stack;
+                item.prefix = r.getUint8();
+            }
+        }
+    }
+}
+
+void readSigns(Reader &r, World &world)
+{
+    world.signs.resize(r.getUint16());
+    for (Sign &sign : world.signs) {
+        sign.text = r.getString();
+        sign.x = r.getUint32();
+        sign.y = r.getUint32();
+    }
+}
+
+void readNPCs(Reader &r, World &world)
+{
+    if (world.version >= 268) {
+        for (int i = r.getUint32(); i > 0; --i) {
+            world.shimmeredNPCs.push_back(r.getUint32());
+        }
+    }
+    // Town NPCs.
+    while (r.getBool()) {
+        NPC npc{};
+        if (world.version >= 190) {
+            npc.id = r.getUint32();
+            switch (npc.id) {
+                // clang-format off
+                case 17: npc.type = "Merchant"; break;
+                case 18: npc.type = "Nurse"; break;
+                case 19: npc.type = "Arms Dealer"; break;
+                case 20: npc.type = "Dryad"; break;
+                case 22: npc.type = "Guide"; break;
+                case 37: npc.type = "Old Man"; break;
+                case 38: npc.type = "Demolitionist"; break;
+                case 54: npc.type = "Clothier"; break;
+                case 107: npc.type = "Goblin Tinkerer"; break;
+                case 108: npc.type = "Wizard"; break;
+                case 124: npc.type = "Mechanic"; break;
+                case 142: npc.type = "Santa Claus"; break;
+                case 160: npc.type = "Truffle"; break;
+                case 178: npc.type = "Steampunker"; break;
+                case 207: npc.type = "Dye Trader"; break;
+                case 208: npc.type = "Party Girl"; break;
+                case 209: npc.type = "Cyborg"; break;
+                case 227: npc.type = "Painter"; break;
+                case 228: npc.type = "Witch Doctor"; break;
+                case 229: npc.type = "Pirate"; break;
+                case 353: npc.type = "Stylist"; break;
+                case 369: npc.type = "Angler"; break;
+                case 441: npc.type = "Tax Collector"; break;
+                case 550: npc.type = "Tavernkeep"; break;
+                case 588: npc.type = "Golfer"; break;
+                case 633: npc.type = "Zoologist"; break;
+                case 637: npc.type = "Town Cat"; break;
+                case 638: npc.type = "Town Dog"; break;
+                case 656: npc.type = "Town Bunny"; break;
+                case 663: npc.type = "Princess"; break;
+                case 670: npc.type = "Nerdy Slime"; break;
+                case 678: npc.type = "Cool Slime"; break;
+                case 679: npc.type = "Elder Slime"; break;
+                case 680: npc.type = "Clumsy Slime"; break;
+                case 681: npc.type = "Diva Slime"; break;
+                case 682: npc.type = "Surly Slime"; break;
+                case 683: npc.type = "Mystic Slime"; break;
+                case 684: npc.type = "Squire Slime"; break;
+                // clang-format on
+            }
+        } else {
+            npc.type = r.getString();
+        }
+        npc.name = r.getString();
+        npc.x = r.getFloat32() / 16;
+        npc.y = r.getFloat32() / 16;
+        npc.isHomeless = r.getBool();
+        npc.homeX = r.getUint32();
+        npc.homeY = r.getUint32();
+        if (world.version >= 213 && r.getBool()) {
+            npc.variation = r.getUint32();
+        }
+        if (world.version >= 315) {
+            npc.homelessDespawn = r.getBool();
+        }
+        world.npcs.push_back(std::move(npc));
+    }
+    if (world.version >= 140) {
+        // Enemies.
+        while (r.getBool()) {
+            NPC npc{};
+            if (world.version >= 190) {
+                npc.id = r.getUint32();
+            } else {
+                npc.type = r.getString();
+            }
+            npc.x = r.getFloat32() / 16;
+            npc.y = r.getFloat32() / 16;
+            world.npcs.push_back(std::move(npc));
+        }
+    }
+}
+
+void readMannequin(TileEntity &entity, Reader &r, World &world)
+{
+    uint16_t itemMask = r.getUint8();
+    uint16_t dyeMask = r.getUint8();
+    int maxSlots = 8;
+    bool hasExtraItem = false;
+    if (world.version >= 315) {
+        maxSlots = 9;
+        r.getUint8(); // Pose.
+        uint16_t extendedMask = r.getUint8();
+        hasExtraItem = (extendedMask & 1) == 1;
+        itemMask |= ((extendedMask >> 1) & 1) << 8;
+        dyeMask |= ((extendedMask >> 2) & 1) << 8;
+    }
+    entity.items.resize(hasExtraItem ? maxSlots + 1 : maxSlots);
+    for (int i = 0; i < maxSlots; ++i) {
+        if ((itemMask & (1 << i)) != 0) {
+            Item &item = entity.items[i];
+            item.id = r.getUint16();
+            item.prefix = r.getUint8();
+            item.stack = r.getUint16();
+        }
+    }
+    entity.dyes.resize(maxSlots);
+    for (int i = 0; i < maxSlots; ++i) {
+        if ((dyeMask & (1 << i)) != 0) {
+            Item &item = entity.dyes[i];
+            item.id = r.getUint16();
+            item.prefix = r.getUint8();
+            item.stack = r.getUint16();
+        }
+    }
+    if (hasExtraItem) {
+        Item &item = entity.items[maxSlots];
+        item.id = r.getUint16();
+        item.prefix = r.getUint8();
+        item.stack = r.getUint16();
+    }
+}
+
+void readHatRack(TileEntity &entity, Reader &r)
+{
+    uint8_t mask = r.getUint8();
+    entity.items.resize(2);
+    for (Item &item : entity.items) {
+        if ((mask & 1) != 0) {
+            item.id = r.getUint16();
+            item.prefix = r.getUint8();
+            item.stack = r.getUint16();
+        }
+        mask >>= 1;
+    }
+    entity.dyes.resize(2);
+    for (Item &item : entity.dyes) {
+        if ((mask & 1) != 0) {
+            item.id = r.getUint16();
+            item.prefix = r.getUint8();
+            item.stack = r.getUint16();
+        }
+        mask >>= 1;
+    }
+}
+
+void readTileEntities(Reader &r, World &world)
+{
+    if (world.version < 140) {
+        return;
+    }
+    for (int i = r.getUint32(); i > 0; --i) {
+        TileEntity entity{};
+        entity.type = r.getUint8();
+        entity.id = r.getUint32();
+        entity.x = r.getUint16();
+        entity.y = r.getUint16();
+        switch (entity.type) {
+        case 0:  // Target dummy.
+        case 9:  // Kite
+        case 10: // Critter
+            r.getUint16();
+            break;
+        case 1: // Item frame.
+        case 4: // Weapon rack.
+        case 6: // Plate.
+        case 8: // Item Flask.
+        {
+            Item item;
+            item.id = r.getUint16();
+            item.prefix = r.getUint8();
+            item.stack = r.getUint16();
+            entity.items.push_back(item);
+            break;
+        }
+        case 2: // Logic sensor.
+            entity.sensorType = r.getUint8();
+            entity.sensorActive = r.getBool();
+            break;
+        case 3: // (Wo)Mannequin.
+            readMannequin(entity, r, world);
+            break;
+        case 5: // Hat rack.
+            readHatRack(entity, r);
+            break;
+        }
+        world.tileEntities.push_back(std::move(entity));
+    }
+}
+
+void readWeightedPressurePlates(Reader &r, World &world)
+{
+    if (world.version < 170) {
+        return;
+    }
+    r.skipBytes(r.getUint32() * 8);
+}
+
+void readTownManager(Reader &r, World &world)
+{
+    if (world.version < 189) {
+        return;
+    }
+    r.skipBytes(r.getUint32() * 12);
+}
+
+void readBestiary(Reader &r, World &world)
+{
+    if (world.version < 210) {
+        return;
+    }
+    // Kills.
+    for (int i = r.getUint32(); i > 0; --i) {
+        r.getString();
+        r.skipBytes(4);
+    }
+    // Seen.
+    for (int i = r.getUint32(); i > 0; --i) {
+        r.getString();
+    }
+    // Chatted.
+    for (int i = r.getUint32(); i > 0; --i) {
+        r.getString();
+    }
+}
+
+void readCreativePowers(Reader &r, World &world)
+{
+    if (world.version < 220) {
+        return;
+    }
+    while (r.getBool()) {
+        switch (r.getUint16()) {
+        case 0:
+            world.creative.freezeTime = r.getBool();
+            break;
+        case 8:
+            world.creative.timeRate = r.getFloat32();
+            break;
+        case 9:
+            world.creative.freezeRainStatus = r.getBool();
+            break;
+        case 10:
+            world.creative.freezeWindStatus = r.getBool();
+            break;
+        case 12:
+            world.creative.difficulty = r.getFloat32();
+            break;
+        case 13:
+            world.creative.freezeBiomeSpread = r.getBool();
+            break;
+        default:
+            return;
+        }
+    }
+}
+
+World readWorldFile(const std::string &data)
+{
+    Reader r{data};
+    World world{};
+    readProperties(r, world);
+    if (!isValidWorldSize(world)) {
+        return world;
+    }
+    readTiles(r, world);
+    readChests(r, world);
+    readSigns(r, world);
+    readNPCs(r, world);
+    readTileEntities(r, world);
+    readWeightedPressurePlates(r, world);
+    readTownManager(r, world);
+    readBestiary(r, world);
+    readCreativePowers(r, world);
+    return world;
+}
diff --git a/wasm/src/WorldLoader.h b/wasm/src/WorldLoader.h
new file mode 100644
index 0000000..ebff487
--- /dev/null
+++ b/wasm/src/WorldLoader.h
@@ -0,0 +1,8 @@
+#ifndef WORLDLOADER_H
+#define WORLDLOADER_H
+
+#include "World.h"
+
+World readWorldFile(const std::string &data);
+
+#endif // WORLDLOADER_H
diff --git a/wasm/src/header.js b/wasm/src/header.js
new file mode 100644
index 0000000..5ec7291
--- /dev/null
+++ b/wasm/src/header.js
@@ -0,0 +1,2 @@
+importScripts('../../../resources/js/settings.js');
+var Module = {};
diff --git a/wasm/src/ieee754_types.hpp b/wasm/src/ieee754_types.hpp
new file mode 100644
index 0000000..a47ed35
--- /dev/null
+++ b/wasm/src/ieee754_types.hpp
@@ -0,0 +1,169 @@
+// https://github.com/kkimdev/ieee754-types
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+#ifndef IEEE754_TYPES_HPP_
+#define IEEE754_TYPES_HPP_
+
+// Based on IEEE 754-2008
+
+#if __cplusplus < 201703L
+#error This file requires C++17
+#endif
+
+#include <climits>
+#include <limits>
+#include <type_traits>
+
+namespace IEEE_754 {
+namespace detail {
+
+template <typename T>
+inline constexpr int get_storage_bits() {
+  return sizeof(T) * CHAR_BIT;
+}
+
+template <typename T>
+inline constexpr int get_exponent_bits() {
+  int exponent_range = ::std::numeric_limits<T>::max_exponent -
+                       ::std::numeric_limits<T>::min_exponent;
+  int bits = 0;
+  while ((exponent_range >> bits) > 0) ++bits;
+  return bits;
+}
+
+template <typename T>
+inline constexpr int get_mantissa_bits() {
+  return ::std::numeric_limits<T>::digits - 1;
+}
+
+template <int storage_bits>
+inline constexpr int standard_binary_interchange_format_exponent_bits() {
+  constexpr bool is_valid_storage_bits =
+      storage_bits == 16 ||   //
+      storage_bits == 32 ||   //
+      storage_bits == 64 ||   //
+      storage_bits == 128 ||  //
+      (storage_bits > 128 && storage_bits % 32 == 0);
+  static_assert(
+      is_valid_storage_bits,
+      "IEEE 754-2008 standard binary interchange formats are only defined for "
+      "the following storage width in bits: 16, 32, 64, 128, and any multiple "
+      "of 32 of at least 128.");
+  static_assert(!(is_valid_storage_bits && storage_bits > 128),
+                "Not Implemented for storage bits larger than 128.");
+
+  if (storage_bits == 16) return 5;
+  if (storage_bits == 32) return 8;
+  if (storage_bits == 64) return 11;
+  if (storage_bits == 128) return 15;
+
+  throw;
+}
+
+template <int storage_bits>
+inline constexpr int standard_binary_interchange_format_mantissa_bits() {
+  return storage_bits -
+         standard_binary_interchange_format_exponent_bits<storage_bits>() - 1;
+}
+
+static_assert(standard_binary_interchange_format_exponent_bits<16>()  == 5,  "");
+static_assert(standard_binary_interchange_format_exponent_bits<32>()  == 8,  "");
+static_assert(standard_binary_interchange_format_exponent_bits<64>()  == 11, "");
+static_assert(standard_binary_interchange_format_exponent_bits<128>() == 15, "");
+
+static_assert(standard_binary_interchange_format_mantissa_bits<16>()  == 10, "");
+static_assert(standard_binary_interchange_format_mantissa_bits<32>()  == 23, "");
+static_assert(standard_binary_interchange_format_mantissa_bits<64>()  == 52, "");
+static_assert(standard_binary_interchange_format_mantissa_bits<128>() == 112,"");
+
+template <int storage_bits, int exponent_bits, int mantissa_bits>
+struct Is_Ieee754_2008_Binary_Interchange_Format {
+  // TODO: as of 2018-06-11 clang-format doesn't handle the following section
+  //       well.
+  // clang-format off
+  template <typename T>
+  static constexpr bool value =
+      ::std::is_floating_point<T>()            &&
+      ::std::numeric_limits<T>::is_iec559      &&
+      ::std::numeric_limits<T>::radix == 2     &&
+      get_storage_bits<T>() == storage_bits    &&
+      get_exponent_bits<T>() == exponent_bits  &&
+      get_mantissa_bits<T>() == mantissa_bits;
+  // clang-format on
+};
+
+template <typename C, typename T, typename... Ts>
+inline constexpr auto find_type() {
+  throw;
+
+  if constexpr (C::template value<T>) {
+    return T();
+  } else if constexpr (sizeof...(Ts) >= 1) {
+    return find_type<C, Ts...>();
+  } else {
+    return void();
+  }
+}
+
+template <int storage_bits,
+          int exponent_bits =
+              standard_binary_interchange_format_exponent_bits<storage_bits>(),
+          int mantissa_bits =
+              standard_binary_interchange_format_mantissa_bits<storage_bits>()>
+using BinaryFloatOrVoid =
+    decltype(find_type<                                                //
+             Is_Ieee754_2008_Binary_Interchange_Format<storage_bits,   //
+                                                       exponent_bits,  //
+                                                       mantissa_bits>,
+             float, double, long double>());
+
+template <typename T>
+struct AssertTypeFound {
+  static_assert(
+      !::std::is_same_v<T, void>,
+      "No corresponding IEEE 754-2008 binary interchange format found.");
+  using type = T;
+};
+
+}  // namespace detail
+
+namespace _2008 {
+template <int storage_bits>
+using Binary = typename detail::AssertTypeFound<
+    detail::BinaryFloatOrVoid<storage_bits>>::type;
+}  // namespace _2008
+
+// Testing
+namespace detail {
+
+template <int storage_bits, int exponent_bits, int mantissa_bits>
+inline void test_if_type_exists() {
+  throw;
+
+  if constexpr (!::std::is_same_v<BinaryFloatOrVoid<storage_bits>, void>) {
+    using T = ::IEEE_754::_2008::Binary<storage_bits>;
+    static_assert(::std::is_floating_point<T>(), "");
+    static_assert(::std::numeric_limits<T>::is_iec559, "");
+    static_assert(::std::numeric_limits<T>::radix == 2, "");
+    static_assert(get_storage_bits<T>() == storage_bits, "");
+    static_assert(get_exponent_bits<T>() == exponent_bits, "");
+    static_assert(get_mantissa_bits<T>() == mantissa_bits, "");
+  }
+}
+
+inline void tests() {
+  throw;
+
+  test_if_type_exists<16, 5, 10>();
+  test_if_type_exists<32, 8, 23>();
+  test_if_type_exists<64, 11, 52>();
+  test_if_type_exists<128, 15, 112>();
+}
+
+}  // namespace detail
+
+}  // namespace IEEE_754
+
+#endif  // IEEE754_TYPES_HPP_
diff --git a/wasm/src/main.cpp b/wasm/src/main.cpp
new file mode 100644
index 0000000..7565c24
--- /dev/null
+++ b/wasm/src/main.cpp
@@ -0,0 +1,737 @@
+#include "TileColor.h"
+#include "WorldLoader.h"
+#include <set>
+
+#ifdef __EMSCRIPTEN__
+#include <emscripten/bind.h>
+
+template <typename T> emscripten::val marshalData(const std::pair<T, T> &pair)
+{
+    return emscripten::val::array(std::vector<T>{pair.first, pair.second});
+}
+
+template <
+    typename C,
+    typename T = std::decay_t<decltype(*std::begin(std::declval<C>()))>>
+emscripten::val marshalData(const C &data)
+{
+    std::vector<emscripten::val> jsData;
+    for (auto &row : data) {
+        jsData.push_back(marshalData(row));
+    }
+    return emscripten::val::array(jsData);
+}
+
+emscripten::val marshalData(const Point &point)
+{
+    auto result = emscripten::val::object();
+    result.set("x", point.x);
+    result.set("y", point.y);
+    return result;
+}
+
+emscripten::val marshalData(const Item &item)
+{
+    auto result = emscripten::val::object();
+    result.set("id", item.id);
+    result.set("stack", item.stack);
+    result.set("prefix", item.prefix);
+    return result;
+}
+
+emscripten::val marshalData(const Chest &chest)
+{
+    auto result = emscripten::val::object();
+    result.set("x", chest.x);
+    result.set("y", chest.y);
+    result.set("name", chest.name);
+    result.set("items", marshalData(chest.items));
+    return result;
+}
+
+emscripten::val marshalData(const Sign &sign)
+{
+    auto result = emscripten::val::object();
+    result.set("x", sign.x);
+    result.set("y", sign.y);
+    result.set("text", sign.text);
+    return result;
+}
+
+emscripten::val marshalData(const NPC &npc)
+{
+    auto result = emscripten::val::object();
+    result.set("id", npc.id);
+    result.set("type", npc.type);
+    result.set("name", npc.name);
+    result.set("x", npc.x);
+    result.set("y", npc.y);
+    result.set("isHomeless", npc.isHomeless);
+    result.set("homeX", npc.homeX);
+    result.set("homeY", npc.homeY);
+    result.set("variation", npc.variation);
+    result.set("homelessDespawn", npc.homelessDespawn);
+    return result;
+}
+
+emscripten::val marshalData(const CreativePowers &pwr)
+{
+    auto result = emscripten::val::object();
+    result.set("freezeTime", pwr.freezeTime);
+    result.set("timeRate", pwr.timeRate);
+    result.set("freezeRainStatus", pwr.freezeRainStatus);
+    result.set("freezeWindStatus", pwr.freezeWindStatus);
+    result.set("difficulty", pwr.difficulty);
+    result.set("freezeBiomeSpread", pwr.freezeBiomeSpread);
+    return result;
+}
+
+std::string marshalData(Liquid liquid)
+{
+    switch (liquid) {
+    case Liquid::none:
+        return "";
+    case Liquid::water:
+        return "Water";
+    case Liquid::lava:
+        return "Lava";
+    case Liquid::honey:
+        return "Honey";
+    case Liquid::shimmer:
+        return "Shimmer";
+    }
+}
+
+std::string marshalData(Slope slope)
+{
+    switch (slope) {
+    case Slope::none:
+        return "";
+    case Slope::half:
+        return "Half";
+    case Slope::topRight:
+        return "Top Right";
+    case Slope::topLeft:
+        return "Top Left";
+    case Slope::bottomRight:
+        return "Bottom Right";
+    case Slope::bottomLeft:
+        return "Bottom Left";
+    }
+}
+
+emscripten::val marshalData(const Tile &tile)
+{
+    auto result = emscripten::val::object();
+    result.set("blockId", tile.blockId);
+    result.set("frameX", tile.frameX);
+    result.set("frameY", tile.frameY);
+    result.set("wallId", tile.wallId);
+    result.set("blockPaint", tile.blockPaint);
+    result.set("wallPaint", tile.wallPaint);
+    result.set("liquidAmount", tile.liquidAmount);
+    result.set("liquid", marshalData(tile.liquid));
+    result.set("slope", marshalData(tile.slope));
+    result.set("wireRed", tile.wireRed);
+    result.set("wireBlue", tile.wireBlue);
+    result.set("wireGreen", tile.wireGreen);
+    result.set("wireYellow", tile.wireYellow);
+    result.set("actuated", tile.actuated);
+    result.set("actuator", tile.actuator);
+    result.set("echoCoatBlock", tile.echoCoatBlock);
+    result.set("echoCoatWall", tile.echoCoatWall);
+    result.set("illuminantBlock", tile.illuminantBlock);
+    result.set("illuminantWall", tile.illuminantWall);
+    return result;
+}
+
+emscripten::val marshalData(const TileEntity &entity)
+{
+    auto result = emscripten::val::object();
+    result.set("id", entity.id);
+    result.set("type", entity.type);
+    result.set("x", entity.x);
+    result.set("y", entity.y);
+    result.set("sensorType", entity.sensorType);
+    result.set("sensorActive", entity.sensorActive);
+    result.set("items", marshalData(entity.items));
+    result.set("dyes", marshalData(entity.dyes));
+    return result;
+}
+
+#define DUMP(field) result.set(#field, world.field)
+#define DUMP_ARRAY(field)                                                      \
+    result.set(                                                                \
+        #field,                                                                \
+        emscripten::val::array(world.field.begin(), world.field.end()))
+#define DUMP_CUSTOM(field) result.set(#field, marshalData(world.field))
+
+emscripten::val dumpWorld(const World &world)
+{
+    auto result = emscripten::val::object();
+#else
+#include <fstream>
+#include <iostream>
+#include <sstream>
+
+template <typename T> void marshalData(const std::vector<T> &data)
+{
+    std::cout << '[';
+    for (auto &row : data) {
+        marshalData(row);
+        std::cout << ',';
+    }
+    std::cout << ']';
+}
+
+void marshalData(const Point &point)
+{
+    std::cout << "{x:" << point.x << ",y:" << point.y << '}';
+}
+
+void marshalData(const Item &item)
+{
+    std::cout << "{id:" << item.id << ",stack:" << item.stack
+              << ",prefix:" << item.prefix << '}';
+}
+
+void marshalData(const Chest &chest)
+{
+    std::cout << "{\nx:" << chest.x << ",y:" << chest.y << ",\nname:\""
+              << chest.name << "\",\nitems:";
+    marshalData(chest.items);
+    std::cout << "\n}";
+}
+
+void marshalData(const Sign &sign)
+{
+    std::cout << "{x:" << sign.x << ",y:" << sign.y << ",text:\"" << sign.text
+              << "\"}";
+}
+
+void marshalData(const NPC &npc)
+{
+    std::cout << "{id:" << npc.id << ",type:\"" << npc.type << "\",name:\""
+              << npc.name << "\",x:" << npc.x << ",y:" << npc.y
+              << ",isHomeless:" << npc.isHomeless << ",homeX:" << npc.homeX
+              << ",homeY:" << npc.homeY << ",variation:" << npc.variation
+              << ",homelessDespawn:" << npc.homelessDespawn << '}';
+}
+
+void marshalData(const CreativePowers &pwr)
+{
+    std::cout << "{freezeTime:" << pwr.freezeTime
+              << ",timeRate:" << pwr.timeRate
+              << ",freezeRainStatus:" << pwr.freezeRainStatus
+              << ",freezeWindStatus:" << pwr.freezeWindStatus
+              << ",difficulty:" << pwr.difficulty
+              << ",freezeBiomeSpread:" << pwr.freezeBiomeSpread << '}';
+}
+
+#define DUMP(field) std::cout << #field " " << world.field << '\n'
+#define DUMP_ARRAY(field)                                                      \
+    do {                                                                       \
+        std::cout << #field " [";                                              \
+        for (auto val : world.field) {                                         \
+            std::cout << val << ',';                                           \
+        };                                                                     \
+        std::cout << "]\n";                                                    \
+    } while (0)
+#define DUMP_CUSTOM(field)                                                     \
+    do {                                                                       \
+        std::cout << #field " ";                                               \
+        marshalData(world.field);                                              \
+        std::cout << '\n';                                                     \
+    } while (0)
+
+void dumpWorld(const World &world)
+{
+#endif
+    DUMP(version);
+    DUMP(revision);
+    DUMP(isFavorite);
+    DUMP_ARRAY(framedTiles);
+
+    DUMP(name);
+    DUMP(seed);
+    DUMP(generatorVersion);
+    DUMP(guid);
+    DUMP(id);
+    DUMP(left);
+    DUMP(right);
+    DUMP(top);
+    DUMP(bottom);
+    DUMP(height);
+    DUMP(width);
+    DUMP(gameMode);
+    DUMP(seedDrunkWorld);
+    DUMP(seedForTheWorthy);
+    DUMP(seedCelebrationmk10);
+    DUMP(seedTheConstant);
+    DUMP(seedNotTheBees);
+    DUMP(seedRemix);
+    DUMP(seedNoTraps);
+    DUMP(seedZenith);
+    DUMP(seedSkyblock);
+    DUMP(creationTime);
+    DUMP(lastPlayed);
+
+    DUMP(moonType);
+    DUMP_ARRAY(treeStyleCoords);
+    DUMP_ARRAY(treeStyles);
+    DUMP_ARRAY(caveStyleCoords);
+    DUMP_ARRAY(caveStyles);
+    DUMP(iceStyle);
+    DUMP(jungleStyle);
+    DUMP(underworldStyle);
+    DUMP_ARRAY(spawn);
+    DUMP(undergroundLevel);
+    DUMP(cavernLevel);
+    DUMP(gameTime);
+    DUMP(isDay);
+    DUMP(moonPhase);
+    DUMP(bloodMoon);
+    DUMP(eclipse);
+    DUMP_ARRAY(dungeon);
+    DUMP(isCrimson);
+
+    DUMP(downedEyeOfCthulu);
+    DUMP(downedEaterOfWorlds);
+    DUMP(downedSkeletron);
+    DUMP(downedQueenBee);
+    DUMP(downedTheDestroyer);
+    DUMP(downedTheTwins);
+    DUMP(downedSkeletronPrime);
+    DUMP(downedAnyHardmodeBoss);
+    DUMP(downedPlantera);
+    DUMP(downedGolem);
+    DUMP(downedSlimeKing);
+    DUMP(savedGoblinTinkerer);
+    DUMP(savedWizard);
+    DUMP(savedMechanic);
+    DUMP(defeatedGoblinInvasion);
+    DUMP(downedClown);
+    DUMP(defeatedFrostLegion);
+    DUMP(defeatedPirates);
+
+    DUMP(brokeAShadowOrb);
+    DUMP(meteorSpawned);
+    DUMP(shadowOrbsBroken);
+    DUMP(altarsSmashed);
+    DUMP(hardMode);
+    DUMP(partyOfDoom);
+    DUMP(goblinInvasionDelay);
+    DUMP(goblinInvasionSize);
+    DUMP(goblinInvasionType);
+    DUMP(goblinInvasionX);
+    DUMP(slimeRainTime);
+    DUMP(sundialCooldown);
+    DUMP(raining);
+    DUMP(rainTimeLeft);
+    DUMP(maxRain);
+    DUMP(cobaltVariant);
+    DUMP(mythrilVariant);
+    DUMP(adamantiteVariant);
+    DUMP(forestStyle1);
+    DUMP(corruptionStyle);
+    DUMP(undergroundJungleStyle);
+    DUMP(snowStyle);
+    DUMP(hallowStyle);
+    DUMP(crimsonStyle);
+    DUMP(desertStyle);
+    DUMP(oceanStyle);
+    DUMP(cloudBackground);
+    DUMP(numberOfClouds);
+    DUMP(windSpeed);
+
+    DUMP_ARRAY(anglersFinishedDailyQuest);
+    DUMP(savedAngler);
+    DUMP(anglerQuest);
+    DUMP(savedStylist);
+    DUMP(savedTaxCollector);
+    DUMP(savedGolfer);
+    DUMP(invasionStartSize);
+    DUMP(cultistDelay);
+    DUMP_ARRAY(enemyKillTallies);
+    DUMP_ARRAY(claimableBanners);
+    DUMP(fastForwardTimeToDawn);
+
+    DUMP(downedFishron);
+    DUMP(downedMartians);
+    DUMP(downedLunaticCultist);
+    DUMP(downedMoonlord);
+    DUMP(downedHalloweenPumpking);
+    DUMP(downedHalloweenMourningWood);
+    DUMP(downedChristmasIceQueen);
+    DUMP(downedChristmasSantaNK1);
+    DUMP(downedChristmasEverscream);
+    DUMP(downedTowerSolar);
+    DUMP(downedTowerVortex);
+    DUMP(downedTowerNebula);
+    DUMP(downedTowerStardust);
+    DUMP(towerActiveSolar);
+    DUMP(towerActiveVortex);
+    DUMP(towerActiveNebula);
+    DUMP(towerActiveStardust);
+    DUMP(lunarApocalypseIsUp);
+
+    DUMP(partyManual);
+    DUMP(partyGenuine);
+    DUMP(partyCooldown);
+    DUMP_ARRAY(partyingNPCs);
+    DUMP(sandstormActive);
+    DUMP(sandstormTimeLeft);
+    DUMP(sandstormSeverity);
+    DUMP(sandstormIntendedSeverity);
+    DUMP(savedBartender);
+    DUMP(downedInvasionTier1);
+    DUMP(downedInvasionTier2);
+    DUMP(downedInvasionTier3);
+    DUMP(mushroomStyle);
+    DUMP(underworldStyle2);
+    DUMP(forestStyle2);
+    DUMP(forestStyle3);
+    DUMP(forestStyle4);
+    DUMP(combatBookUsed);
+    DUMP(lanternNightCooldown);
+    DUMP(lanternNightGenuine);
+    DUMP(lanternNightManual);
+    DUMP(lanternNightNextIsGenuine);
+    DUMP_ARRAY(treeTopVariations);
+    DUMP(forceHalloween);
+    DUMP(forceChristmas);
+    DUMP(copperVariant);
+    DUMP(ironVariant);
+    DUMP(silverVariant);
+    DUMP(goldVariant);
+    DUMP(boughtCat);
+    DUMP(boughtDog);
+    DUMP(boughtBunny);
+
+    DUMP(downedEmpressOfLight);
+    DUMP(downedQueenSlime);
+    DUMP(downedDeerclops);
+    DUMP(unlockedNerdySlime);
+    DUMP(unlockedMerchant);
+    DUMP(unlockedDemolitionist);
+    DUMP(unlockedPartyGirl);
+    DUMP(unlockedDyeTrader);
+    DUMP(unlockedTruffle);
+    DUMP(unlockedArmsDealer);
+    DUMP(unlockedNurse);
+    DUMP(unlockedPrincess);
+    DUMP(combatBookVolumeTwoUsed);
+    DUMP(peddlersSatchelUsed);
+    DUMP(unlockedCoolSlime);
+    DUMP(unlockedElderSlime);
+    DUMP(unlockedClumsySlime);
+    DUMP(unlockedDivaSlime);
+    DUMP(unlockedSurlySlime);
+    DUMP(unlockedMysticSlime);
+    DUMP(unlockedSquireSlime);
+    DUMP(fastForwardTimeToDusk);
+    DUMP(moondialCooldown);
+    DUMP(seedEndlessHalloween);
+    DUMP(seedEndlessChristmas);
+    DUMP(seedVampirism);
+    DUMP(seedInfectedWorld);
+    DUMP(meteorShowerCount);
+    DUMP(coinRain);
+    DUMP(seedTeamBasedSpawns);
+    DUMP_CUSTOM(extraSpawnPoints);
+    DUMP(seedDualDungeons);
+    DUMP(worldGenManifest);
+
+    DUMP_CUSTOM(chests);
+    DUMP_CUSTOM(signs);
+    DUMP_ARRAY(shimmeredNPCs);
+    DUMP_CUSTOM(npcs);
+    DUMP_CUSTOM(creative);
+#ifdef __EMSCRIPTEN__
+    return result;
+}
+#else
+}
+#endif
+
+#ifdef __EMSCRIPTEN__
+class Loader
+{
+    World world;
+    std::map<int, int> chestLookup;
+    std::map<int, int> signLookup;
+    std::map<int, int> entityLookup;
+    std::vector<std::pair<int, int>> searchResults;
+
+    void searchBlocks(
+        const std::set<int> &blockIds,
+        std::set<std::pair<int, int>> &results)
+    {
+        for (int x = 0; x < world.width; ++x) {
+            for (int y = 0; y < world.height; ++y) {
+                if (blockIds.contains(world.getTile(x, y).blockId)) {
+                    results.emplace(x, y);
+                }
+            }
+        }
+    }
+
+    void searchFramedBlocks(
+        int blockId,
+        int minU,
+        int maxU,
+        int minV,
+        int maxV,
+        std::set<std::pair<int, int>> &results)
+    {
+        for (int x = 0; x < world.width; ++x) {
+            for (int y = 0; y < world.height; ++y) {
+                Tile &tile = world.getTile(x, y);
+                if (tile.blockId == blockId && tile.frameX >= minU &&
+                    tile.frameX < maxU && tile.frameY >= minV &&
+                    tile.frameY < maxV) {
+                    results.emplace(x, y);
+                }
+            }
+        }
+    }
+
+    void searchWalls(int wallId, std::set<std::pair<int, int>> &results)
+    {
+        for (int x = 0; x < world.width; ++x) {
+            for (int y = 0; y < world.height; ++y) {
+                if (world.getTile(x, y).wallId == wallId) {
+                    results.emplace(x, y);
+                }
+            }
+        }
+    }
+
+    std::pair<int, int> parseLookupKey(int lookupKey)
+    {
+        int y = lookupKey % world.height;
+        return {(lookupKey - y) / world.height, y};
+    }
+
+    void searchItems(int itemId, std::set<std::pair<int, int>> &results)
+    {
+        for (auto [lookupKey, chestId] : chestLookup) {
+            for (const Item &item : world.chests[chestId].items) {
+                if (item.id == itemId) {
+                    results.insert(parseLookupKey(lookupKey));
+                    break;
+                }
+            }
+        }
+        for (auto [lookupKey, entityId] : entityLookup) {
+            const TileEntity &entity = world.tileEntities[entityId];
+            for (const Item &item : entity.items) {
+                if (item.id == itemId) {
+                    results.insert(parseLookupKey(lookupKey));
+                    break;
+                }
+            }
+            for (const Item &item : entity.dyes) {
+                if (item.id == itemId) {
+                    results.insert(parseLookupKey(lookupKey));
+                    break;
+                }
+            }
+        }
+    }
+
+    void putImageData(const std::vector<uint32_t> &pixels, const char *ctx)
+    {
+        EM_ASM(
+            {
+                const data =
+                    new Uint8ClampedArray(wasmMemory.buffer, $0, $1 * $2 * 4);
+                const imageData = new ImageData(data, $1);
+                self[UTF8ToString($3)].putImageData(imageData, 0, 0);
+            },
+            pixels.data(),
+            world.width,
+            world.height,
+            ctx);
+    }
+
+public:
+    emscripten::val loadWorldFile(const std::string &data)
+    {
+        world = readWorldFile(data);
+        chestLookup.clear();
+        for (size_t chestId = 0; chestId < world.chests.size(); ++chestId) {
+            const Chest &chest = world.chests[chestId];
+            int maxI = world.getTile(chest.x, chest.y).blockId == 88 ? 3 : 2;
+            for (int i = 0; i < maxI; ++i) {
+                for (int j = 0; j < 2; ++j) {
+                    chestLookup[(chest.x + i) * world.height + chest.y + j] =
+                        chestId;
+                }
+            }
+        }
+        signLookup.clear();
+        for (size_t signId = 0; signId < world.signs.size(); ++signId) {
+            const Sign &sign = world.signs[signId];
+            for (int i = 0; i < 2; ++i) {
+                for (int j = 0; j < 2; ++j) {
+                    signLookup[(sign.x + i) * world.height + sign.y + j] =
+                        signId;
+                }
+            }
+        }
+        entityLookup.clear();
+        for (size_t entityId = 0; entityId < world.tileEntities.size();
+             ++entityId) {
+            const TileEntity &entity = world.tileEntities[entityId];
+            int maxI = 1;
+            int maxJ = 1;
+            switch (entity.type) {
+            case 1: // Item frame.
+                maxI = 2;
+                maxJ = 2;
+                break;
+            case 3: // (Wo)Mannequin.
+                maxI = 2;
+                maxJ = 3;
+                break;
+            case 4: // Weapon rack.
+                maxI = 3;
+                maxJ = 3;
+                break;
+            case 5: // Hat rack.
+                maxI = 3;
+                maxJ = 4;
+                break;
+            }
+            for (int i = 0; i < maxI; ++i) {
+                for (int j = 0; j < maxJ; ++j) {
+                    entityLookup[(entity.x + i) * world.height + entity.y + j] =
+                        entityId;
+                }
+            }
+        }
+        searchResults.clear();
+        return dumpWorld(world);
+    }
+
+    void renderToCanvas()
+    {
+        std::vector<uint32_t> pixels;
+        pixels.reserve(world.width * world.height);
+        std::vector<double> errCur(3 * (world.width + 1));
+        std::vector<double> errNext(3 * (world.width + 1));
+        for (int y = 0; y < world.height; ++y) {
+            for (int x = 0; x < world.width; ++x) {
+                pixels.push_back(
+                    getTileColor(x, y, errCur, errNext, world).abgr);
+            }
+            errCur.swap(errNext);
+            std::fill(errNext.begin(), errNext.end(), 0);
+        }
+        putImageData(pixels, "ctx");
+    }
+
+    emscripten::val getTile(int x, int y)
+    {
+        if (x < 0 || y < 0 || x >= world.width || y >= world.height) {
+            return emscripten::val::null();
+        }
+        auto result = marshalData(world.getTile(x, y));
+        int lookupKey = x * world.height + y;
+        auto chestItr = chestLookup.find(lookupKey);
+        if (chestItr != chestLookup.end()) {
+            result.set("chest", marshalData(world.chests[chestItr->second]));
+        }
+        auto signItr = signLookup.find(lookupKey);
+        if (signItr != signLookup.end()) {
+            result.set("sign", marshalData(world.signs[signItr->second]));
+        }
+        auto entityItr = entityLookup.find(lookupKey);
+        if (entityItr != entityLookup.end()) {
+            result.set(
+                "tileEntity",
+                marshalData(world.tileEntities[entityItr->second]));
+        }
+        return result;
+    }
+
+    void search(const emscripten::val &queries)
+    {
+        int numQueries = queries["length"].as<int>();
+        std::set<std::pair<int, int>> results;
+        std::set<int> blockIds;
+        for (int i = 0; i < numQueries; ++i) {
+            int id = queries[i]["id"].as<int>();
+            switch (queries[i]["type"].as<int>()) {
+            case 0:
+                blockIds.insert(id);
+                break;
+            case 1:
+                searchFramedBlocks(
+                    id,
+                    queries[i]["minU"].as<int>(),
+                    queries[i]["maxU"].as<int>(),
+                    queries[i]["minV"].as<int>(),
+                    queries[i]["maxV"].as<int>(),
+                    results);
+                break;
+            case 2:
+                searchWalls(id, results);
+                break;
+            case 3:
+                searchItems(id, results);
+                break;
+            }
+        }
+        if (!blockIds.empty()) {
+            searchBlocks(blockIds, results);
+        }
+        searchResults.clear();
+        searchResults.assign(results.begin(), results.end());
+
+        std::vector<uint32_t> pixels(world.width * world.height, 0xbf000000);
+        for (auto [x, y] : searchResults) {
+            pixels[y * world.width + x] = 0xffffffff;
+        }
+        putImageData(pixels, "overlayCtx");
+    }
+
+    emscripten::val findNext(int x, int y, int direction)
+    {
+        std::pair pt{x, y};
+        auto bound =
+            std::lower_bound(searchResults.begin(), searchResults.end(), pt);
+        if (direction < 0) {
+            if (bound == searchResults.begin()) {
+                return emscripten::val::null();
+            }
+            --bound;
+        } else if (bound != searchResults.end() && *bound == pt) {
+            ++bound;
+        }
+        return bound == searchResults.end() ? emscripten::val::null()
+                                            : marshalData(*bound);
+    }
+};
+
+EMSCRIPTEN_BINDINGS(terramap)
+{
+    emscripten::class_<Loader>("Loader")
+        .constructor()
+        .function("loadWorldFile", &Loader::loadWorldFile)
+        .function("renderToCanvas", &Loader::renderToCanvas)
+        .function("getTile", &Loader::getTile)
+        .function("search", &Loader::search)
+        .function("findNext", &Loader::findNext);
+}
+#else
+int main()
+{
+    std::ifstream in("/path/to/Test_World.wld", std::ios::binary);
+    std::ostringstream sstr;
+    sstr << in.rdbuf();
+    std::string data{sstr.str()};
+    dumpWorld(readWorldFile(data));
+}
+#endif
diff --git a/wasm/src/pre.js b/wasm/src/pre.js
new file mode 100644
index 0000000..737361c
--- /dev/null
+++ b/wasm/src/pre.js
@@ -0,0 +1,8 @@
+Module.initializedPromise = new Promise((resolve) => {
+  Module['onRuntimeInitialized'] = resolve;
+});
+
+Module['terramap'] = async () => {
+  await Module.initializedPromise;
+  return new Module['Loader']();
+};
diff --git a/wasm/src/worker.js b/wasm/src/worker.js
new file mode 100644
index 0000000..e403d4c
--- /dev/null
+++ b/wasm/src/worker.js
@@ -0,0 +1,200 @@
+self.addEventListener('message', (e) => {
+  if (e.data.canvas) {
+    self.canvas = e.data.canvas;
+    self.ctx = self.canvas.getContext('2d');
+    self.ctx.msImageSmoothingEnabled = false;
+    self.ctx.mozImageSmoothingEnabled = false;
+    self.ctx.imageSmoothingEnabled = false;
+  }
+  if (e.data.overlayCanvas) {
+    self.overlayCanvas = e.data.overlayCanvas;
+    self.overlayCtx = self.overlayCanvas.getContext('2d');
+    self.overlayCtx.msImageSmoothingEnabled = false;
+    self.overlayCtx.mozImageSmoothingEnabled = false;
+    self.overlayCtx.imageSmoothingEnabled = false;
+  }
+  if (e.data.file) {
+    self.start(e.data.file);
+  }
+  if (e.data.hoverTile) {
+    onHoverTile(e.data.hoverTile);
+  }
+  if (e.data.selectTile) {
+    onSelectTile(e.data.selectTile);
+  }
+  if (e.data.search) {
+    onSearch(e.data.search);
+  }
+  if (e.data.clearHighlight) {
+    const { width, height } = self.overlayCanvas;
+    self.overlayCtx.clearRect(0, 0, width, height);
+  }
+  if (e.data.findNext) {
+    onFindNext(e.data.findNext);
+  }
+});
+
+async function start(file) {
+  const fileReader = new FileReaderSync();
+
+  self.postMessage({ status: 'Reading world file...' });
+  const buffer = fileReader.readAsArrayBuffer(file);
+
+  self.postMessage({ status: 'Loading world file...' });
+  if (typeof self.terramap === 'undefined') {
+    self.terramap = await Module.terramap();
+  }
+  const world = self.terramap.loadWorldFile(buffer);
+  console.log(world);
+  if (
+    world.width <= 0 ||
+    world.height <= 0 ||
+    world.width > 33600 ||
+    world.height > 9600
+  ) {
+    return;
+  }
+  self.canvas.width = world.width;
+  self.canvas.height = world.height;
+  self.overlayCanvas.width = world.width;
+  self.overlayCanvas.height = world.height;
+
+  self.postMessage({ status: 'Rendering tiles...', world });
+  self.terramap.renderToCanvas();
+  self.postMessage({ status: 'Done.', done: true });
+}
+
+function getTileInfo(tile) {
+  const tileInfo = settings.Tiles[tile.blockId];
+  if (tileInfo && tileInfo.Frames) {
+    for (const frame of tileInfo.Frames.slice().reverse()) {
+      if (
+        ((!frame.U && !tile.frameX) || frame.U <= tile.frameX) &&
+        ((!frame.V && !tile.frameY) || frame.V <= tile.frameY)
+      ) {
+        frame.parent = tileInfo;
+        return frame;
+      }
+    }
+  }
+  return tileInfo;
+}
+
+function getTileText(tile) {
+  let text = 'Nothing';
+  const tileInfo = getTileInfo(tile);
+  if (tileInfo) {
+    if (tileInfo.parent && tileInfo.parent.Name) {
+      text = tileInfo.parent.Name;
+      if (tileInfo.Name) {
+        text += ` - ${tileInfo.Name}`;
+      }
+      if (tileInfo.Variety) {
+        text += ` - ${tileInfo.Variety}`;
+      }
+    } else {
+      text = tileInfo.Name;
+    }
+
+    if (tile.frameX === 0 && tile.frameY === 0) {
+      text += ` (${tile.blockId})`;
+    } else {
+      text += ` (${tile.blockId}, ${tile.frameX}, ${tile.frameY})`;
+    }
+    if (tile.tileEntity) {
+      const entity = tile.tileEntity;
+      if (entity.type === 2) {
+        const sensorType = tileInfo.CheckTypes[entity.sensorType];
+        const on = entity.sensorActive ? 'On' : 'Off';
+        text += ` - ${sensorType}, ${on}`;
+      } else if (entity.items.length === 1) {
+        const itemId = entity.items[0].id;
+        for (const itemSettings of settings.Items) {
+          if (Number(itemSettings.Id) === itemId) {
+            text += ` - ${itemSettings.Name}`;
+            break;
+          }
+        }
+      }
+    }
+  } else if (tile.wallId >= settings.Walls.length) {
+    text = `Unknown Wall (${tile.wallId})`;
+  } else if (tile.wallId > 0) {
+    text = `${settings.Walls[tile.wallId].Name} (${tile.wallId})`;
+  }
+
+  if (tile.liquid) {
+    text = text === 'Nothing' ? tile.liquid : `${text} ${tile.liquid}`;
+  }
+  const flagFields = [
+    ['wireRed', 'Red Wire'],
+    ['wireBlue', 'Blue Wire'],
+    ['wireGreen', 'Green Wire'],
+    ['wireYellow', 'Yellow Wire'],
+    ['actuator', 'Actuator'],
+  ];
+  const flags = [];
+  for (const [key, label] of flagFields) {
+    if (tile[key]) {
+      flags.push(label);
+    }
+  }
+  if (flags.length > 0) {
+    text += ` (${flags.join(', ')})`;
+  }
+
+  return text;
+}
+
+function onHoverTile({ x, y }) {
+  const tile = self.terramap.getTile(x, y);
+  if (tile) {
+    self.postMessage({ status: `${getTileText(tile)} (${x}, ${y})` });
+  }
+}
+
+function onSelectTile({ x, y }) {
+  const tile = self.terramap.getTile(x, y);
+  if (tile) {
+    tile.text = getTileText(tile);
+    self.postMessage({ tile });
+  }
+}
+
+function onSearch(search) {
+  const queries = [];
+  for (const info of search) {
+    if (info.isTile) {
+      if (info.parent) {
+        let sizeX = 1;
+        let sizeY = 1;
+        if (info.parent.Size) {
+          sizeX = info.parent.Size[0] - '0';
+          sizeY = info.parent.Size[2] - '0';
+        }
+        queries.push({
+          type: 1,
+          id: Number(info.parent.Id),
+          minU: info.U,
+          maxU: info.U + 18 * sizeX,
+          minV: info.V,
+          maxV: info.V + 18 * sizeY,
+        });
+      } else {
+        queries.push({ type: 0, id: Number(info.Id) });
+      }
+    } else if (info.isWall) {
+      queries.push({ type: 2, id: Number(info.Id) });
+    } else if (info.isItem) {
+      queries.push({ type: 3, id: Number(info.Id) });
+    }
+  }
+  self.terramap.search(queries);
+}
+
+function onFindNext({ x, y, direction }) {
+  const pos = self.terramap.findNext(x, y, direction);
+  if (pos) {
+    self.postMessage({ select: { x: pos[0], y: pos[1] } });
+  }
+}