diff --git a/presets/verilog/sprite_rotation.v b/presets/verilog/sprite_rotation.v
index eea6dc1f..5c22a662 100644
--- a/presets/verilog/sprite_rotation.v
+++ b/presets/verilog/sprite_rotation.v
@@ -1,4 +1,4 @@
-
+
 `ifndef SPRITE_ROTATION_H
 `define SPRITE_ROTATION_H
 
@@ -20,90 +20,90 @@ module tank_bitmap(addr, bits);
   assign bits = (addr[0]) ? bitarray[addr>>1][15:8] : bitarray[addr>>1][7:0];
   
   initial begin/*{w:16,h:16,bpw:16,count:5}*/
-    bitarray[8'h00] = 16'b11110000000;
-    bitarray[8'h01] = 16'b11110000000;
-    bitarray[8'h02] = 16'b1100000000;
-    bitarray[8'h03] = 16'b1100000000;
-    bitarray[8'h04] = 16'b111101101111000;
-    bitarray[8'h05] = 16'b111101101111000;
-    bitarray[8'h06] = 16'b111111111111000;
-    bitarray[8'h07] = 16'b111111111111000;
-    bitarray[8'h08] = 16'b111111111111000;
-    bitarray[8'h09] = 16'b111111111111000;
-    bitarray[8'h0a] = 16'b111111111111000;
-    bitarray[8'h0b] = 16'b111100001111000;
-    bitarray[8'h0c] = 16'b111100001111000;
-    bitarray[8'h0d] = 16'b0;
-    bitarray[8'h0e] = 16'b0;
-    bitarray[8'h0f] = 16'b0;
+    bitarray['h00] = 16'b11110000000;
+    bitarray['h01] = 16'b11110000000;
+    bitarray['h02] = 16'b1100000000;
+    bitarray['h03] = 16'b1100000000;
+    bitarray['h04] = 16'b111101101111000;
+    bitarray['h05] = 16'b111101101111000;
+    bitarray['h06] = 16'b111111111111000;
+    bitarray['h07] = 16'b111111111111000;
+    bitarray['h08] = 16'b111111111111000;
+    bitarray['h09] = 16'b111111111111000;
+    bitarray['h0a] = 16'b111111111111000;
+    bitarray['h0b] = 16'b111100001111000;
+    bitarray['h0c] = 16'b111100001111000;
+    bitarray['h0d] = 16'b0;
+    bitarray['h0e] = 16'b0;
+    bitarray['h0f] = 16'b0;
     
-    bitarray[8'h10] = 16'b111000000000;
-    bitarray[8'h11] = 16'b1111000000000;
-    bitarray[8'h12] = 16'b1111000000000;
-    bitarray[8'h13] = 16'b11000000000;
-    bitarray[8'h14] = 16'b11101110000;
-    bitarray[8'h15] = 16'b1101110000;
-    bitarray[8'h16] = 16'b111101111110000;
-    bitarray[8'h17] = 16'b111101111111000;
-    bitarray[8'h18] = 16'b111111111111000;
-    bitarray[8'h19] = 16'b11111111111000;
-    bitarray[8'h1a] = 16'b11111111111100;
-    bitarray[8'h1b] = 16'b11111111111100;
-    bitarray[8'h1c] = 16'b11111001111100;
-    bitarray[8'h1d] = 16'b1111001110000;
-    bitarray[8'h1e] = 16'b1111000000000;
-    bitarray[8'h1f] = 16'b1100000000000;
+    bitarray['h10] = 16'b111000000000;
+    bitarray['h11] = 16'b1111000000000;
+    bitarray['h12] = 16'b1111000000000;
+    bitarray['h13] = 16'b11000000000;
+    bitarray['h14] = 16'b11101110000;
+    bitarray['h15] = 16'b1101110000;
+    bitarray['h16] = 16'b111101111110000;
+    bitarray['h17] = 16'b111101111111000;
+    bitarray['h18] = 16'b111111111111000;
+    bitarray['h19] = 16'b11111111111000;
+    bitarray['h1a] = 16'b11111111111100;
+    bitarray['h1b] = 16'b11111111111100;
+    bitarray['h1c] = 16'b11111001111100;
+    bitarray['h1d] = 16'b1111001110000;
+    bitarray['h1e] = 16'b1111000000000;
+    bitarray['h1f] = 16'b1100000000000;
     
-    bitarray[8'h20] = 16'b0;
-    bitarray[8'h21] = 16'b0;
-    bitarray[8'h22] = 16'b11000011000000;
-    bitarray[8'h23] = 16'b111000111100000;
-    bitarray[8'h24] = 16'b111101111110000;
-    bitarray[8'h25] = 16'b1110111111000;
-    bitarray[8'h26] = 16'b111111111100;
-    bitarray[8'h27] = 16'b11111111110;
-    bitarray[8'h28] = 16'b11011111111110;
-    bitarray[8'h29] = 16'b111111111111100;
-    bitarray[8'h2a] = 16'b111111111001000;
-    bitarray[8'h2b] = 16'b11111110000000;
-    bitarray[8'h2c] = 16'b1111100000000;
-    bitarray[8'h2d] = 16'b111110000000;
-    bitarray[8'h2e] = 16'b11110000000;
-    bitarray[8'h2f] = 16'b1100000000;
+    bitarray['h20] = 16'b0;
+    bitarray['h21] = 16'b0;
+    bitarray['h22] = 16'b11000011000000;
+    bitarray['h23] = 16'b111000111100000;
+    bitarray['h24] = 16'b111101111110000;
+    bitarray['h25] = 16'b1110111111000;
+    bitarray['h26] = 16'b111111111100;
+    bitarray['h27] = 16'b11111111110;
+    bitarray['h28] = 16'b11011111111110;
+    bitarray['h29] = 16'b111111111111100;
+    bitarray['h2a] = 16'b111111111001000;
+    bitarray['h2b] = 16'b11111110000000;
+    bitarray['h2c] = 16'b1111100000000;
+    bitarray['h2d] = 16'b111110000000;
+    bitarray['h2e] = 16'b11110000000;
+    bitarray['h2f] = 16'b1100000000;
 
-    bitarray[8'h30] = 16'b0;
-    bitarray[8'h31] = 16'b0;
-    bitarray[8'h32] = 16'b110000000;
-    bitarray[8'h33] = 16'b100001111000000;
-    bitarray[8'h34] = 16'b1110001111110000;
-    bitarray[8'h35] = 16'b1111010111111100;
-    bitarray[8'h36] = 16'b1111111111111111;
-    bitarray[8'h37] = 16'b1111111111111;
-    bitarray[8'h38] = 16'b11111111110;
-    bitarray[8'h39] = 16'b101111111110;
-    bitarray[8'h3a] = 16'b1111111101100;
-    bitarray[8'h3b] = 16'b11111111000000;
-    bitarray[8'h3c] = 16'b1111111100000;
-    bitarray[8'h3d] = 16'b11111110000;
-    bitarray[8'h3e] = 16'b111100000;
-    bitarray[8'h3f] = 16'b1100000;
+    bitarray['h30] = 16'b0;
+    bitarray['h31] = 16'b0;
+    bitarray['h32] = 16'b110000000;
+    bitarray['h33] = 16'b100001111000000;
+    bitarray['h34] = 16'b1110001111110000;
+    bitarray['h35] = 16'b1111010111111100;
+    bitarray['h36] = 16'b1111111111111111;
+    bitarray['h37] = 16'b1111111111111;
+    bitarray['h38] = 16'b11111111110;
+    bitarray['h39] = 16'b101111111110;
+    bitarray['h3a] = 16'b1111111101100;
+    bitarray['h3b] = 16'b11111111000000;
+    bitarray['h3c] = 16'b1111111100000;
+    bitarray['h3d] = 16'b11111110000;
+    bitarray['h3e] = 16'b111100000;
+    bitarray['h3f] = 16'b1100000;
 
-    bitarray[8'h40] = 16'b0;
-    bitarray[8'h41] = 16'b0;
-    bitarray[8'h42] = 16'b0;
-    bitarray[8'h43] = 16'b111111111000;
-    bitarray[8'h44] = 16'b111111111000;
-    bitarray[8'h45] = 16'b111111111000;
-    bitarray[8'h46] = 16'b111111111000;
-    bitarray[8'h47] = 16'b1100001111100000;
-    bitarray[8'h48] = 16'b1111111111100000;
-    bitarray[8'h49] = 16'b1111111111100000;
-    bitarray[8'h4a] = 16'b1100001111100000;
-    bitarray[8'h4b] = 16'b111111111000;
-    bitarray[8'h4c] = 16'b111111111000;
-    bitarray[8'h4d] = 16'b111111111000;
-    bitarray[8'h4e] = 16'b111111111000;
-    bitarray[8'h4f] = 16'b0;
+    bitarray['h40] = 16'b0;
+    bitarray['h41] = 16'b0;
+    bitarray['h42] = 16'b0;
+    bitarray['h43] = 16'b111111111000;
+    bitarray['h44] = 16'b111111111000;
+    bitarray['h45] = 16'b111111111000;
+    bitarray['h46] = 16'b111111111000;
+    bitarray['h47] = 16'b1100001111100000;
+    bitarray['h48] = 16'b1111111111100000;
+    bitarray['h49] = 16'b1111111111100000;
+    bitarray['h4a] = 16'b1100001111100000;
+    bitarray['h4b] = 16'b111111111000;
+    bitarray['h4c] = 16'b111111111000;
+    bitarray['h4d] = 16'b111111111000;
+    bitarray['h4e] = 16'b111111111000;
+    bitarray['h4f] = 16'b0;
   end
 endmodule
 
diff --git a/presets/verilog/sprite_scanline_renderer.v b/presets/verilog/sprite_scanline_renderer.v
index 4d733bbe..945cf3fd 100644
--- a/presets/verilog/sprite_scanline_renderer.v
+++ b/presets/verilog/sprite_scanline_renderer.v
@@ -19,22 +19,22 @@ module example_bitmap_rom(addr, data);
   assign data = bitarray[addr & 15];
   
   initial begin/*{w:16,h:16,bpw:16,count:1}*/
-    bitarray[8'h00] = 16'b11110000000;
-    bitarray[8'h01] = 16'b100001000000;
-    bitarray[8'h02] = 16'b1111111100000;
-    bitarray[8'h03] = 16'b1111111100000;
-    bitarray[8'h04] = 16'b11110000000;
-    bitarray[8'h05] = 16'b11111111110000;
-    bitarray[8'h06] = 16'b111100001111000;
-    bitarray[8'h07] = 16'b1111101101111100;
-    bitarray[8'h08] = 16'b1101100001101111;
-    bitarray[8'h09] = 16'b1101111111100110;
-    bitarray[8'h0a] = 16'b1001111111100000;
-    bitarray[8'h0b] = 16'b1111111100000;
-    bitarray[8'h0c] = 16'b1110011100000;
-    bitarray[8'h0d] = 16'b1100001100000;
-    bitarray[8'h0e] = 16'b1100001100000;
-    bitarray[8'h0f] = 16'b11100001110000;
+    bitarray['h00] = 16'b11110000000;
+    bitarray['h01] = 16'b100001000000;
+    bitarray['h02] = 16'b1111111100000;
+    bitarray['h03] = 16'b1111111100000;
+    bitarray['h04] = 16'b11110000000;
+    bitarray['h05] = 16'b11111111110000;
+    bitarray['h06] = 16'b111100001111000;
+    bitarray['h07] = 16'b1111101101111100;
+    bitarray['h08] = 16'b1101100001101111;
+    bitarray['h09] = 16'b1101111111100110;
+    bitarray['h0a] = 16'b1001111111100000;
+    bitarray['h0b] = 16'b1111111100000;
+    bitarray['h0c] = 16'b1110011100000;
+    bitarray['h0d] = 16'b1100001100000;
+    bitarray['h0e] = 16'b1100001100000;
+    bitarray['h0f] = 16'b11100001110000;
   end
 
 endmodule
diff --git a/src/pixed/pixeleditor.ts b/src/pixed/pixeleditor.ts
index b2a3c5d6..cde33a39 100644
--- a/src/pixed/pixeleditor.ts
+++ b/src/pixed/pixeleditor.ts
@@ -2,6 +2,32 @@
 
 import { hex } from "../util";
 
+type PixelEditorImageFormat = {
+  w:number
+  h:number
+  count?:number
+  bpp?:number
+  np?:number
+  bpw?:number
+  sl?:number
+  pofs?:number
+  remap?:number[]
+  brev?:boolean
+  destfmt?:PixelEditorImageFormat
+};
+
+type PixelEditorPaletteFormat = {
+  pal?:number
+  n?:number
+};
+
+type PixelEditorMessage = {
+  fmt : PixelEditorImageFormat
+  palfmt : PixelEditorPaletteFormat
+  bytestr : string
+  palstr : string
+};
+
 export function PixelEditor(parentDiv:HTMLElement, fmt, palette, initialData, thumbnails?) {
   var self = this;
   var width = fmt.w;
@@ -219,7 +245,7 @@ export function PixelEditor(parentDiv:HTMLElement, fmt, palette, initialData, th
 
 var pixel_re = /([0#]?)([x$%]|\d'[bh])([0-9a-f]+)/gi;
 
-function convertToHexStatements(s) {
+function convertToHexStatements(s:string) {
   // convert 'hex ....' asm format
   return s.replace(/(\shex\s+)([0-9a-f]+)/ig, function(m,hexprefix,hexstr) {
     var rtn = hexprefix;
@@ -230,11 +256,12 @@ function convertToHexStatements(s) {
   });
 }
 
-export function parseHexBytes(s) {
+export function parseHexWords(s:string) {
   var arr = [];
   var m;
   while (m = pixel_re.exec(s)) {
     var n;
+    console.log(m);
     if (m[2].startsWith('%') || m[2].endsWith("b"))
       n = parseInt(m[3],2);
     else if (m[2].startsWith('x') || m[2].startsWith('$') || m[2].endsWith('h'))
@@ -246,7 +273,7 @@ export function parseHexBytes(s) {
   return arr;
 }
 
-export function replaceHexBytes(s, bytes) {
+export function replaceHexWords(s:string, words:number[]) {
   var result = "";
   var m;
   var li = 0;
@@ -255,17 +282,17 @@ export function replaceHexBytes(s, bytes) {
     result += s.slice(li, pixel_re.lastIndex - m[0].length);
     li = pixel_re.lastIndex;
     if (m[2].startsWith('%'))
-      result += m[1] + "%" + bytes[i++].toString(2);
+      result += m[1] + "%" + words[i++].toString(2);
     else if (m[2].endsWith('b'))
-      result += m[1] + m[2] + bytes[i++].toString(2); // TODO
+      result += m[1] + m[2] + words[i++].toString(2); // TODO
     else if (m[2].endsWith('h'))
-      result += m[1] + m[2] + bytes[i++].toString(16); // TODO
+      result += m[1] + m[2] + words[i++].toString(16); // TODO
     else if (m[2].startsWith('x'))
-      result += m[1] + "x" + hex(bytes[i++]);
+      result += m[1] + "x" + hex(words[i++]);
     else if (m[2].startsWith('$'))
-      result += m[1] + "$" + hex(bytes[i++]);
+      result += m[1] + "$" + hex(words[i++]);
     else
-      result += m[1] + bytes[i++].toString();
+      result += m[1] + words[i++].toString();
   }
   result += s.slice(li);
   // convert 'hex ....' asm format
@@ -277,7 +304,7 @@ export function replaceHexBytes(s, bytes) {
   return result;
 }
 
-function remapBits(x, arr) {
+function remapBits(x:number, arr:number[]) {
   if (!arr) return x;
   var y = 0;
   for (var i=0; i<arr.length; i++) {
@@ -293,27 +320,27 @@ function remapBits(x, arr) {
   return y;
 }
 
-function convertBytesToImages(bytes, fmt) {
+function convertWordsToImages(words:number[], fmt:PixelEditorImageFormat) {
   var width = fmt.w;
   var height = fmt.h;
   var count = fmt.count || 1;
   var bpp = fmt.bpp || 1;
   var nplanes = fmt.np || 1;
   var bitsperword = fmt.bpw || 8;
-  var bytesperline = fmt.sl || Math.ceil(width * bpp / bitsperword);
+  var wordsperline = fmt.sl || Math.ceil(width * bpp / bitsperword);
   var mask = (1 << bpp)-1;
-  var pofs = fmt.pofs || bytesperline*height*count;
+  var pofs = fmt.pofs || wordsperline*height*count;
   var images = [];
   for (var n=0; n<count; n++) {
     var imgdata = [];
     for (var y=0; y<height; y++) {
-      var ofs0 = n*bytesperline*height + y*bytesperline;
+      var ofs0 = n*wordsperline*height + y*wordsperline;
       var shift = 0;
       for (var x=0; x<width; x++) {
         var color = 0;
         var ofs = remapBits(ofs0, fmt.remap);
         for (var p=0; p<nplanes; p++) {
-          var byte = bytes[ofs + p*pofs];
+          var byte = words[ofs + p*pofs];
           color |= ((fmt.brev ? byte>>(bitsperword-shift-bpp) : byte>>shift) & mask) << (p*bpp);
         }
         imgdata.push(color);
@@ -329,7 +356,7 @@ function convertBytesToImages(bytes, fmt) {
   return images;
 }
 
-function convertImagesToBytes(images, fmt) {
+function convertImagesToWords(images, fmt:PixelEditorImageFormat) : number[] {
   if (fmt.destfmt) fmt = fmt.destfmt;
   var width = fmt.w;
   var height = fmt.h;
@@ -337,26 +364,26 @@ function convertImagesToBytes(images, fmt) {
   var bpp = fmt.bpp || 1;
   var nplanes = fmt.np || 1;
   var bitsperword = fmt.bpw || 8;
-  var bytesperline = fmt.sl || Math.ceil(fmt.w * bpp / bitsperword);
+  var wordsperline = fmt.sl || Math.ceil(fmt.w * bpp / bitsperword);
   var mask = (1 << bpp)-1;
-  var pofs = fmt.pofs || bytesperline*height*count;
-  var bytes;
+  var pofs = fmt.pofs || wordsperline*height*count;
+  var words;
   if (bitsperword <= 8)
-    bytes = new Uint8Array(bytesperline*height*count*nplanes);
+    words = new Uint8Array(wordsperline*height*count*nplanes);
   else
-    bytes = new Uint32Array(bytesperline*height*count*nplanes);
+    words = new Uint32Array(wordsperline*height*count*nplanes);
   for (var n=0; n<count; n++) {
     var imgdata = images[n];
     var i = 0;
     for (var y=0; y<height; y++) {
-      var ofs0 = n*bytesperline*height + y*bytesperline;
+      var ofs0 = n*wordsperline*height + y*wordsperline;
       var shift = 0;
       for (var x=0; x<width; x++) {
         var color = imgdata[i++];
         var ofs = remapBits(ofs0, fmt.remap);
         for (var p=0; p<nplanes; p++) {
           var c = (color >> (p*bpp)) & mask;
-          bytes[ofs + p*pofs] |= (fmt.brev ? (c << (bitsperword-shift-bpp)) : (c << shift));
+          words[ofs + p*pofs] |= (fmt.brev ? (c << (bitsperword-shift-bpp)) : (c << shift));
         }
         shift += bpp;
         if (shift >= bitsperword) {
@@ -366,7 +393,7 @@ function convertImagesToBytes(images, fmt) {
       }
     }
   }
-  return bytes;
+  return words;
 }
 
 function convertPaletteBytes(arr,r0,r1,g0,g1,b0,b1) {
@@ -389,24 +416,25 @@ export var currentPixelEditor;
 export var parentSource;
 export var parentOrigin;
 export var allimages;
-export var currentFormat;
-export var currentByteStr;
-export var currentPaletteStr;
-export var currentPaletteFmt;
+export var currentFormat : PixelEditorImageFormat;
+export var currentByteStr : string;
+export var currentPaletteStr : string;
+export var currentPaletteFmt : PixelEditorPaletteFormat;
 export var allthumbs;
 
 export function pixelEditorDecodeMessage(e) {
   parentSource = e.source;
   parentOrigin = e.origin;
+  let data : PixelEditorMessage = e.data;
   currentFormat = e.data.fmt;
-  currentPaletteFmt = e.data.palfmt;
-  currentPaletteStr = e.data.palstr;
-  currentByteStr = convertToHexStatements(e.data.bytestr);
-  var bytes = parseHexBytes(currentByteStr);
-  allimages = convertBytesToImages(bytes, e.data.fmt);
+  currentPaletteFmt = data.palfmt;
+  currentPaletteStr = data.palstr;
+  currentByteStr = convertToHexStatements(data.bytestr);
+  var words = parseHexWords(currentByteStr);
+  allimages = convertWordsToImages(words, data.fmt);
   palette = [0xff000000, 0xffffffff]; // TODO
   if (currentPaletteStr) {
-    var palbytes = parseHexBytes(e.data.palstr);
+    var palbytes = parseHexWords(data.palstr);
     var pal = currentPaletteFmt.pal;
     if (pal > 0) {
       var rr = Math.floor(Math.abs(pal/100) % 10);
@@ -491,8 +519,8 @@ function postToParentWindow(data) {
     for (var i=0; i<allthumbs.length; i++) {
       allimgs.push(allthumbs[i].getImageColors());
     }
-    data.bytes = convertImagesToBytes(allimgs, currentFormat);
-    data.bytestr = replaceHexBytes(currentByteStr, data.bytes);
+    data.bytes = convertImagesToWords(allimgs, currentFormat);
+    data.bytestr = replaceHexWords(currentByteStr, data.bytes);
   }
   if (parentSource) parentSource.postMessage(data, "*");
   return data;