diff --git a/README.md b/README.md
index b6ff6c19f..0d439b139 100644
--- a/README.md
+++ b/README.md
@@ -9,9 +9,14 @@ yet to integrate it into Firefox. We will explore that possibility once
 pdf.js is production ready. Until then we aim to publish a Firefox
 PDF reader extension powered by pdf.js.
 
+Our demo site is here:
+
+  http://andreasgal.github.com/pdf.js/
+
 You can read more about pdf.js here:
 
   http://andreasgal.com/2011/06/15/pdf-js/
+
   http://blog.mozilla.com/cjones/2011/06/15/overview-of-pdf-js-guts/
 
 follow us on twitter: @pdfjs
diff --git a/fonts.js b/fonts.js
index 3db99daf3..12d7ce82e 100644
--- a/fonts.js
+++ b/fonts.js
@@ -36,13 +36,13 @@ var kDisableFonts = false;
  *      http://cgit.freedesktop.org/poppler/poppler/tree/poppler/GfxFont.cc#n65
  */
 
-var Fonts = (function () {
+var Fonts = (function Fonts() {
   var kScalePrecision = 40;
-  var fonts = Object.create(null);  
+  var fonts = Object.create(null);
 
   if (!isWorker) {
     var ctx = document.createElement("canvas").getContext("2d");
-    ctx.scale(1 / kScalePrecision, 1);    
+    ctx.scale(1 / kScalePrecision, 1);
   }
 
   function Font(name, data, properties) {
@@ -124,30 +124,148 @@ var Fonts = (function () {
 })();
 
 var FontLoader = {
-  bind: function(fonts) {
-    var ready = true;
+  listeningForFontLoad: false,
 
-    for (var i = 0; i < fonts.length; i++) {
-      var font = fonts[i];
-      if (Fonts.lookup(font.name)) {
-        ready = ready && !Fonts.lookup(font.name).loading;
-        continue;
+  bind: function(fonts, callback) {
+    function checkFontsLoaded() {
+      for (var i = 0; i < fonts.length; i++) {
+        var font = fonts[i];
+        if (Fonts.lookup(font.name).loading) {
+          return false;
+        }
       }
 
-      ready = false;
+      document.documentElement.removeEventListener(
+        "pdfjsFontLoad", checkFontsLoaded, false);
 
-      var obj = new Font(font.name, font.file, font.properties);
-
-      var str = "";
-      var data = Fonts.lookup(font.name).data;
-      var length = data.length;
-      for (var j = 0; j < length; j++)
-        str += String.fromCharCode(data[j]);
-
-      isWorker ? obj.bindWorker(str) : obj.bindDOM(str);
+      callback();
+      return true;
     }
 
-    return ready;
+    var rules = [ ], names = [ ];
+    for (var i = 0; i < fonts.length; i++) {
+      var font = fonts[i];
+      if (!Fonts.lookup(font.name)) {
+        var obj = new Font(font.name, font.file, font.properties);
+
+        var str = "";
+        var data = Fonts.lookup(font.name).data;
+        var length = data.length;
+        for (var j = 0; j < length; j++)
+          str += String.fromCharCode(data[j]);
+
+        var rule = isWorker ? obj.bindWorker(str) : obj.bindDOM(str);
+        if (rule) {
+          rules.push(rule);
+          names.push(font.name);
+        }
+      }
+    }
+
+    if (!isWorker && rules.length) {
+      FontLoader.prepareFontLoadEvent(rules, names);
+    }
+
+    if (!checkFontsLoaded()) {
+      document.documentElement.addEventListener(
+        "pdfjsFontLoad", checkFontsLoaded, false);
+    }
+
+    return;
+  },
+  // Set things up so that at least one pdfjsFontLoad event is
+  // dispatched when all the @font-face |rules| for |names| have been
+  // loaded in a subdocument.  It's expected that the load of |rules|
+  // has already started in this (outer) document, so that they should
+  // be ordered before the load in the subdocument.
+  prepareFontLoadEvent: function(rules, names) {
+      /** Hack begin */
+      // There's no event when a font has finished downloading so the
+      // following code is a dirty hack to 'guess' when a font is
+      // ready.  This code will be obsoleted by Mozilla bug 471915.
+      //
+      // The only reliable way to know if a font is loaded in Gecko
+      // (at the moment) is document.onload in a document with
+      // a @font-face rule defined in a "static" stylesheet.  We use a
+      // subdocument in an <iframe>, set up properly, to know when
+      // our @font-face rule was loaded.  However, the subdocument and
+      // outer document can't share CSS rules, so the inner document
+      // is only part of the puzzle.  The second piece is an invisible
+      // div created in order to force loading of the @font-face in
+      // the *outer* document.  (The font still needs to be loaded for
+      // its metrics, for reflow).  We create the div first for the
+      // outer document, then create the iframe.  Unless something
+      // goes really wonkily, we expect the @font-face for the outer
+      // document to be processed before the inner.  That's still
+      // fragile, but seems to work in practice.
+      //
+      // The postMessage() hackery was added to work around chrome bug
+      // 82402.
+
+      var div = document.createElement("div");
+      div.setAttribute("style",
+                       'visibility: hidden;'+
+                       'width: 10px; height: 10px;'+
+                       'position: absolute; top: 0px; left: 0px;');
+      var html = '';
+      for (var i = 0; i < names.length; ++i) {
+        html += '<span style="font-family:'+ names[i] +'">Hi</span>';
+      }
+      div.innerHTML = html;
+      document.body.appendChild(div);
+
+      if (!this.listeneningForFontLoad) {
+        window.addEventListener(
+          "message",
+          function(e) {
+            var fontNames = e.data;
+            // Firefox 5 doesn't parse the JSON here.  Welcome to the
+            // Wonderful Web World.
+            if ("string" == typeof(fontNames)) {
+              fontNames = fontNames.split(",");
+            }
+            for (var i = 0; i < fontNames.length; ++i) {
+              var font = Fonts.lookup(fontNames[i]);
+              font.loading = false;
+            }
+            var evt = document.createEvent("Events");
+            evt.initEvent("pdfjsFontLoad", true, false);
+            document.documentElement.dispatchEvent(evt);
+          },
+          false);
+        this.listeneningForFontLoad = true;
+      }
+
+      // XXX we should have a time-out here too, and maybe fire
+      // pdfjsFontLoadFailed?
+      var src = '<!DOCTYPE HTML><html><head>';
+      src += '<style type="text/css">';
+      for (var i = 0; i < rules.length; ++i) {
+        src += rules[i];
+      }
+      src += '</style>'
+      src += '<script type="application/javascript">'
+      var fontNamesArray = '';
+      for (var i = 0; i < names.length; ++i) {
+        fontNamesArray += '"'+ names[i] + '", ';
+      }
+      src += '  var fontNames=['+ fontNamesArray +'];\n';
+      src += '  window.onload = function () {\n'
+      src += '    top.postMessage(fontNames, "*");\n';
+      src += '  }';
+      src += '</script></head><body>';
+      for (var i = 0; i < names.length; ++i) {
+        src += '<p style="font-family:\''+ fontName +'\'">Hi</p>';
+      }
+      src += '</body></html>';
+      var frame = document.createElement("iframe");
+      frame.src = 'data:text/html,'+ src;
+      frame.setAttribute("style",
+                         'visibility: hidden;'+
+                         'width: 10px; height: 10px;'+
+                         'position: absolute; top: 0px; left: 0px;');
+      document.body.appendChild(frame);
+      /** Hack end */
   }
 };
 
@@ -348,6 +466,29 @@ var Font = (function () {
     return array;
   };
 
+  function int16(bytes) {
+    return (bytes[0] << 8) + (bytes[1] & 0xff);
+  };
+
+  function int32(bytes) {
+    return (bytes[0] << 24) + (bytes[1] << 16) +
+           (bytes[2] << 8) + (bytes[3] & 0xff);
+  };
+
+  function getMaxPower2(number) {
+    var maxPower = 0;
+    var value = number;
+    while (value >= 2) {
+      value /= 2;
+      maxPower++;
+    }
+
+    value = 2;
+    for (var i = 1; i < maxPower; i++)
+      value *= 2;
+    return value;
+  };
+
   function string16(value) {
     return String.fromCharCode((value >> 8) & 0xff) +
            String.fromCharCode(value & 0xff);
@@ -368,7 +509,7 @@ var Font = (function () {
     header += string16(numTables);
 
     // searchRange (2 bytes)
-    var tablesMaxPower2 = FontsUtils.getMaxPower2(numTables);
+    var tablesMaxPower2 = getMaxPower2(numTables);
     var searchRange = tablesMaxPower2 * 16;
     header += string16(searchRange);
 
@@ -389,7 +530,7 @@ var Font = (function () {
 
     // length
     var length = data.length;
-	
+
     // Per spec tables must be 4-bytes align so add padding as needed
     while (data.length & 3)
       data.push(0x00);
@@ -400,7 +541,7 @@ var Font = (function () {
     // checksum
     var checksum = 0;
     for (var i = 0; i < length; i+=4)
-      checksum += FontsUtils.bytesToInteger([data[i], data[i+1], data[i+2], data[i+3]]);
+      checksum += int16([data[i], data[i+1], data[i+2], data[i+3]]);
 
     var tableEntry = tag + string32(checksum) + string32(offset) + string32(length);
     tableEntry = stringToArray(tableEntry);
@@ -437,25 +578,27 @@ var Font = (function () {
     glyphs.push({ unicode: 0x0000 });
     var ranges = getRanges(glyphs);
 
-    var headerSize = (12 * 2 + (ranges.length * 4 * 2));
+    var numTables = 1;
+    var cmap = "\x00\x00" + // version
+               string16(numTables) +  // numTables
+               "\x00\x03" + // platformID
+               "\x00\x01" + // encodingID
+               string32(4 + numTables * 8); // start of the table record
+
+    var headerSize = (12 * 2 + (ranges.length * 5 * 2));
     var segCount = ranges.length + 1;
     var segCount2 = segCount * 2;
-    var searchRange = FontsUtils.getMaxPower2(segCount) * 2;
+    var searchRange = getMaxPower2(segCount) * 2;
     var searchEntry = Math.log(segCount) / Math.log(2);
     var rangeShift = 2 * segCount - searchRange;
 
-    var cmap = "\x00\x00" + // version
-               "\x00\x01" + // numTables
-               "\x00\x03" + // platformID
-               "\x00\x01" + // encodingID
-               "\x00\x00\x00\x0C" + // start of the table record
-               "\x00\x04" + // format
-               string16(headerSize) + // length
-               "\x00\x00" + // languages
-               string16(segCount2) +
-               string16(searchRange) +
-               string16(searchEntry) +
-               string16(rangeShift);
+    var format314 = "\x00\x04" + // format
+                    string16(headerSize) + // length
+                    "\x00\x00" + // language
+                    string16(segCount2) +
+                    string16(searchRange) +
+                    string16(searchEntry) +
+                    string16(rangeShift);
 
     // Fill up the 4 parallel arrays describing the segments.
     var startCount = "";
@@ -468,25 +611,27 @@ var Font = (function () {
       var range = ranges[i];
       var start = range[0];
       var end = range[1];
-      var delta = (((start - 1) - bias) ^ 0xffff);
+      var delta = (bias - start) % 0xffff;
       bias += (end - start + 1);
 
       startCount += string16(start);
       endCount += string16(end);
       idDeltas += string16(delta);
-	  idRangeOffsets += string16(0);
+	    idRangeOffsets += string16(0);
 
-      for (var j = 0; j < range.length; j++)
-        glyphsIds += String.fromCharCode(range[j]);
+      for (var j = start; j <= end; j++) {
+        glyphsIds += string16(j);
+      }
     }
 
-    startCount += "\xFF\xFF";
     endCount += "\xFF\xFF";
+    startCount += "\xFF\xFF";
     idDeltas += "\x00\x01";
     idRangeOffsets += "\x00\x00";
+    format314 += endCount + "\x00\x00" + startCount +
+                 idDeltas + idRangeOffsets + glyphsIds;
 
-    return stringToArray(cmap + endCount + "\x00\x00" + startCount +
-                         idDeltas + idRangeOffsets + glyphsIds);
+    return stringToArray(cmap + format314);
   };
 
   function createOS2Table(properties) {
@@ -526,7 +671,7 @@ var Font = (function () {
            "\x02\x24" + // xAvgCharWidth
            "\x01\xF4" + // usWeightClass
            "\x00\x05" + // usWidthClass
-           "\x00\x02" + // fstype
+           "\x00\x00" + // fstype (0 to let the font loads via font-face on IE)
            "\x02\x8A" + // ySubscriptXSize
            "\x02\xBB" + // ySubscriptYSize
            "\x00\x00" + // ySubscriptXOffset
@@ -590,9 +735,9 @@ var Font = (function () {
               String.fromCharCode(tag[2]) +
               String.fromCharCode(tag[3]);
 
-        var checksum = FontsUtils.bytesToInteger(file.getBytes(4));
-        var offset = FontsUtils.bytesToInteger(file.getBytes(4));
-        var length = FontsUtils.bytesToInteger(file.getBytes(4));
+        var checksum = int32(file.getBytes(4));
+        var offset = int32(file.getBytes(4));
+        var length = int32(file.getBytes(4));
 
         // Read the table associated data
         var previousPosition = file.pos;
@@ -613,24 +758,26 @@ var Font = (function () {
       function readOpenTypeHeader(ttf) {
         return {
           version: ttf.getBytes(4),
-          numTables: FontsUtils.bytesToInteger(ttf.getBytes(2)),
-          searchRange: FontsUtils.bytesToInteger(ttf.getBytes(2)),
-          entrySelector: FontsUtils.bytesToInteger(ttf.getBytes(2)),
-          rangeShift: FontsUtils.bytesToInteger(ttf.getBytes(2))
+          numTables: int16(ttf.getBytes(2)),
+          searchRange: int16(ttf.getBytes(2)),
+          entrySelector: int16(ttf.getBytes(2)),
+          rangeShift: int16(ttf.getBytes(2))
         }
       };
 
       function replaceCMapTable(cmap, font, properties) {
-        var version = FontsUtils.bytesToInteger(font.getBytes(2));
-        var numTables = FontsUtils.bytesToInteger(font.getBytes(2));
+        font.pos = (font.start ? font.start : 0) + cmap.length;
+
+        var version = int16(font.getBytes(2));
+        var numTables = int16(font.getBytes(2));
 
         for (var i = 0; i < numTables; i++) {
-          var platformID = FontsUtils.bytesToInteger(font.getBytes(2));
-          var encodingID = FontsUtils.bytesToInteger(font.getBytes(2));
-          var offset = FontsUtils.bytesToInteger(font.getBytes(4));
-          var format = FontsUtils.bytesToInteger(font.getBytes(2));
-          var length = FontsUtils.bytesToInteger(font.getBytes(2));
-          var language = FontsUtils.bytesToInteger(font.getBytes(2));
+          var platformID = int16(font.getBytes(2));
+          var encodingID = int16(font.getBytes(2));
+          var offset = int32(font.getBytes(4));
+          var format = int16(font.getBytes(2));
+          var length = int16(font.getBytes(2));
+          var language = int16(font.getBytes(2));
 
           if ((format == 0 && numTables == 1) ||
               (format == 6 && numTables == 1 && !properties.encoding.empty)) {
@@ -652,13 +799,13 @@ var Font = (function () {
             // table. (This looks weird, so I can have missed something), this
             // works on Linux but seems to fails on Mac so let's rewrite the
             // cmap table to a 3-1-4 style
-            var firstCode = FontsUtils.bytesToInteger(font.getBytes(2));
-            var entryCount = FontsUtils.bytesToInteger(font.getBytes(2));
+            var firstCode = int16(font.getBytes(2));
+            var entryCount = int16(font.getBytes(2));
 
             var glyphs = [];
             var min = 0xffff, max = 0;
             for (var j = 0; j < entryCount; j++) {
-              var charcode = FontsUtils.bytesToInteger(font.getBytes(2));
+              var charcode = int16(font.getBytes(2));
               glyphs.push(charcode);
 
               if (charcode < min)
@@ -758,7 +905,7 @@ var Font = (function () {
 
         // Tables needs to be written by ascendant alphabetic order
         tables.sort(function tables_sort(a, b) {
-          return a.tag > b.tag;
+          return (a.tag > b.tag) - (a.tag < b.tag);
         });
 
         // rewrite the tables but tweak offsets
@@ -797,8 +944,6 @@ var Font = (function () {
     },
 
     convert: function font_convert(fontName, font, properties) {
-      var otf = new Uint8Array(kMaxFontFileSize);
-
       function createNameTable(name) {
   	    // All the strings of the name table should be an odd number of bytes
         if (name.length % 2)
@@ -861,7 +1006,7 @@ var Font = (function () {
 		    nameTable += strings.join("") + stringsUnicode.join("");
         return nameTable;
       }
-	  
+
 	    function isFixedPitch(glyphs) {
 	      for (var i = 0; i < glyphs.length - 1; i++) {
 		    if (glyphs[i] != glyphs[i+1])
@@ -870,46 +1015,34 @@ var Font = (function () {
 		    return true;
       };
 
-      // Required Tables
-      var CFF =
-        font.data,   // PostScript Font Program
-        OS2,         // OS/2 and Windows Specific metrics
-        cmap,        // Character to glyphs mapping
-        head,        // Font header
-        hhea,        // Horizontal header
-        hmtx,        // Horizontal metrics
-        maxp,        // Maximum profile
-        name,        // Naming tables
-        post;        // PostScript informations
-      var tables = [CFF, OS2, cmap, head, hhea, hmtx, maxp, name, post];
-
       // The offsets object holds at the same time a representation of where
       // to write the table entry information about a table and another offset
       // representing the offset where to draw the actual data of a particular
       // table
+      var kRequiredTablesCount = 9;
       var offsets = {
         currentOffset: 0,
-        virtualOffset: tables.length * (4 * 4)
+        virtualOffset: 9 * (4 * 4)
       };
 
-      // It there is only one font, offset table is the first bytes of the file
-      createOpenTypeHeader("\x4F\x54\x54\x4F", otf, offsets, tables.length);
+      var otf = new Uint8Array(kMaxFontFileSize);
+      createOpenTypeHeader("\x4F\x54\x54\x4F", otf, offsets, 9);
 
-      /** CFF */
-      createTableEntry(otf, offsets, "CFF ", CFF);
-
-      /** OS/2 */
 	    var charstrings = font.charstrings;
 	    properties.fixedPitch = isFixedPitch(charstrings);
-      OS2 = stringToArray(createOS2Table(properties));
-      createTableEntry(otf, offsets, "OS/2", OS2);
+      var fields = {
+        // PostScript Font Program
+        "CFF ": font.data,
 
-      /** CMAP */
-      cmap = createCMapTable(charstrings.slice());
-      createTableEntry(otf, offsets, "cmap", cmap);
+        // OS/2 and Windows Specific metrics
+        "OS/2": stringToArray(createOS2Table(properties)),
 
-      /** HEAD */
-      head = stringToArray(
+        // Character to glyphs mapping
+        "cmap": createCMapTable(charstrings.slice()),
+
+        // Font header
+        "head": (function() {
+          return stringToArray(
               "\x00\x01\x00\x00" + // Version number
               "\x00\x00\x10\x00" + // fontRevision
               "\x00\x00\x00\x00" + // checksumAdjustement
@@ -926,63 +1059,59 @@ var Font = (function () {
               "\x00\x11" + // lowestRecPPEM
               "\x00\x00" + // fontDirectionHint
               "\x00\x00" + // indexToLocFormat
-              "\x00\x00"   // glyphDataFormat
-      );
-      createTableEntry(otf, offsets, "head", head);
+              "\x00\x00");  // glyphDataFormat
+        })(),
 
-      /** HHEA */
-      hhea = stringToArray(
-                 "\x00\x01\x00\x00" + // Version number
-                 string16(properties.ascent) + // Typographic Ascent
-                 string16(properties.descent) + // Typographic Descent
-                 "\x00\x00" + // Line Gap
-                 "\xFF\xFF" + // advanceWidthMax
-                 "\x00\x00" + // minLeftSidebearing
-                 "\x00\x00" + // minRightSidebearing
-                 "\x00\x00" + // xMaxExtent
-                 string16(properties.capHeight) + // caretSlopeRise
-                 string16(Math.tan(properties.italicAngle) * properties.xHeight) + // caretSlopeRun
-                 "\x00\x00" + // caretOffset
-                 "\x00\x00" + // -reserved-
-                 "\x00\x00" + // -reserved-
-                 "\x00\x00" + // -reserved-
-                 "\x00\x00" + // -reserved-
-                 "\x00\x00" + // metricDataFormat
-                 string16(charstrings.length + 1) // Number of HMetrics
-      );
-      createTableEntry(otf, offsets, "hhea", hhea);
+        // Horizontal header
+        "hhea": (function() {
+          return stringToArray(
+              "\x00\x01\x00\x00" + // Version number
+              string16(properties.ascent) + // Typographic Ascent
+              string16(properties.descent) + // Typographic Descent
+              "\x00\x00" + // Line Gap
+              "\xFF\xFF" + // advanceWidthMax
+              "\x00\x00" + // minLeftSidebearing
+              "\x00\x00" + // minRightSidebearing
+              "\x00\x00" + // xMaxExtent
+              string16(properties.capHeight) + // caretSlopeRise
+              string16(Math.tan(properties.italicAngle) * properties.xHeight) + // caretSlopeRun
+              "\x00\x00" + // caretOffset
+              "\x00\x00" + // -reserved-
+              "\x00\x00" + // -reserved-
+              "\x00\x00" + // -reserved-
+              "\x00\x00" + // -reserved-
+              "\x00\x00" + // metricDataFormat
+              string16(charstrings.length + 1)); // Number of HMetrics
+        })(),
 
-      /** HMTX */
-      /* For some reasons, probably related to how the backend handle fonts,
-      * Linux seems to ignore this file and prefer the data from the CFF itself
-      * while Windows use this data. So be careful if you hack on Linux and
-      * have to touch the 'hmtx' table
-      */
-      hmtx = "\x00\x00\x00\x00"; // Fake .notdef
-      for (var i = 0; i < charstrings.length; i++) {
-        hmtx += string16(charstrings[i].width) + string16(0);
-      }
-      hmtx = stringToArray(hmtx);
-      createTableEntry(otf, offsets, "hmtx", hmtx);
+        // Horizontal metrics
+        "hmtx": (function() {
+          var hmtx = "\x00\x00\x00\x00"; // Fake .notdef
+          for (var i = 0; i < charstrings.length; i++) {
+            hmtx += string16(charstrings[i].width) + string16(0);
+          }
+          return stringToArray(hmtx);
+        })(),
 
-      /** MAXP */
-      maxp = "\x00\x00\x50\x00" + // Version number
-             string16(charstrings.length + 1); // Num of glyphs
-      maxp = stringToArray(maxp);
-      createTableEntry(otf, offsets, "maxp", maxp);
+        // Maximum profile
+        "maxp": (function() {
+          return stringToArray(
+              "\x00\x00\x50\x00" + // Version number
+             string16(charstrings.length + 1)); // Num of glyphs
+        })(),
 
-      /** NAME */
-      name = stringToArray(createNameTable(fontName));
-      createTableEntry(otf, offsets, "name", name);
+        // Naming tables
+        "name": stringToArray(createNameTable(fontName)),
 
-      /** POST */
-      post = stringToArray(createPostTable(properties));
-      createTableEntry(otf, offsets, "post", post);
+        // PostScript informations
+        "post": stringToArray(createPostTable(properties))
+      };
 
-      // Once all the table entries header are written, dump the data!
-      var tables = [CFF, OS2, cmap, head, hhea, hmtx, maxp, name, post];
-      for (var i = 0; i < tables.length; i++) {
-        var table = tables[i];
+      for (var field in fields)
+        createTableEntry(otf, offsets, field, fields[field]);
+
+      for (var field in fields) {
+        var table = fields[field];
         otf.set(table, offsets.currentOffset);
         offsets.currentOffset += table.length;
       }
@@ -1004,114 +1133,22 @@ var Font = (function () {
       });
     },
 
-    bindDOM: function font_bindDom(data, callback) {
+    bindDOM: function font_bindDom(data) {
       var fontName = this.name;
 
-      // Just adding the font-face to the DOM doesn't make it load. It
-      // seems it's loaded once Gecko notices it's used. Therefore,
-      // add a div on the page using the loaded font.
-      var div = document.createElement("div");
-      var style = 'font-family:"' + name +
-        '";position: absolute;top:-99999;left:-99999;z-index:-99999';
-      div.setAttribute("style", style);
-      document.body.appendChild(div);
-
-      /** Hack begin */
-      // Actually there is not event when a font has finished downloading so
-      // the following code are a dirty hack to 'guess' when a font is ready
-      // This code could go away when bug 471915 has landed
-      var canvas = document.createElement("canvas");
-      var ctx = canvas.getContext("2d");
-      ctx.font = "bold italic 20px " + fontName + ", Symbol, Arial";
-      var testString = "    ";
-
-      // Periodicaly check for the width of the testString, it will be
-      // different once the real font has loaded
-      var textWidth = ctx.measureText(testString).width;
-
-      var interval = window.setInterval(function canvasInterval(self) {
-        this.start = this.start || Date.now();
-        ctx.font = "bold italic 20px " + fontName + ", Symbol, Arial";
-
-        // For some reasons the font has not loaded, so mark it loaded for the
-        // page to proceed but cry
-        if (textWidth == ctx.measureText(testString).width) {
-          if ((Date.now() - this.start) < kMaxWaitForFontFace) {
-            return;
-          } else {
-            warn("Is " + fontName + " loaded?");
-          }
-        }
-
-        window.clearInterval(interval);
-        Fonts.lookup(fontName).loading = false;
-        this.start = 0;
-        if (callback) {
-          callback();
-        }
-      }, 30, this);
-
-      /** Hack end */
-
       // Add the @font-face rule to the document
       var url = "url(data:" + this.mimetype + ";base64," + window.btoa(data) + ");";
       var rule = "@font-face { font-family:'" + fontName + "';src:" + url + "}";
       var styleSheet = document.styleSheets[0];
       styleSheet.insertRule(rule, styleSheet.cssRules.length);
+
+      return rule;
     }
   };
 
   return constructor;
 })();
 
-
-/**
- * FontsUtils is a static class dedicated to hold codes that are not related
- * to fonts in particular and needs to be share between them.
- */
-var FontsUtils = {
-  _bytesArray: new Uint8Array(4),
-  integerToBytes: function fu_integerToBytes(value, bytesCount) {
-    var bytes = this._bytesArray;
-
-    if (bytesCount == 1) {
-      bytes.set([value]);
-      return bytes[0];
-    } else if (bytesCount == 2) {
-      bytes.set([value >> 8, value & 0xff]);
-      return [bytes[0], bytes[1]];
-    } else if (bytesCount == 4) {
-      bytes.set([value >> 24, value >> 16, value >> 8, value]);
-      return [bytes[0], bytes[1], bytes[2], bytes[3]];
-    }
-
-    error("This number of bytes " + bytesCount + " is not supported");
-    return null;
-  },
-
-  bytesToInteger: function fu_bytesToInteger(bytesArray) {
-    var value = 0;
-    for (var i = 0; i < bytesArray.length; i++)
-      value = (value << 8) + bytesArray[i];
-    return value;
-  },
-
-  getMaxPower2: function fu_getMaxPower2(number) {
-    var maxPower = 0;
-    var value = number;
-    while (value >= 2) {
-      value /= 2;
-      maxPower++;
-    }
-
-    value = 2;
-    for (var i = 1; i < maxPower; i++)
-      value *= 2;
-    return value;
-  }
-};
-
-
 /**
  * Type1Parser encapsulate the needed code for parsing a Type1 font
  * program.
@@ -1332,15 +1369,36 @@ var Type1Parser = function() {
    * Returns an object containing a Subrs array and a CharStrings array
    * extracted from and eexec encrypted block of data
    */
-  this.extractFontProgram = function t1_extractFontProgram(stream) {
-    var eexecString = decrypt(stream, kEexecEncryptionKey, 4);
-    var subrs = [],  glyphs = [];
-    var inGlyphs = false;
-    var inSubrs = false;
-    var glyph = "";
+  function readNumberArray(str, index) {
+    var start = ++index;
+    var count = 0;
+    while (str[index++] != "]")
+      count++;
 
+    var array = str.substr(start, count).split(" ");
+    for (var i = 0; i < array.length; i++)
+      array[i] = parseFloat(array[i] || 0);
+    return array;
+  };
+
+  this.extractFontProgram = function t1_extractFontProgram(stream) {
+    var eexec = decrypt(stream, kEexecEncryptionKey, 4);
+    var eexecString = "";
+    for (var i = 0; i < eexec.length; i++)
+      eexecString += String.fromCharCode(eexec[i]);
+
+    var glyphsSection = false, subrsSection = false;
+    var extracted = {
+      subrs: [],
+      charstrings: [],
+      properties: {
+        stemSnapH: [0, 0],
+        stemSnapV: [0, 0]
+      }
+    };
+
+    var glyph = "";
     var token = "";
-    var index = 0;
     var length = 0;
 
     var c = "";
@@ -1348,53 +1406,95 @@ var Type1Parser = function() {
     for (var i = 0; i < count; i++) {
       var c = eexecString[i];
 
-      if (inSubrs && c == 0x52) {
-        length = parseInt(length);
-        var data = eexecString.slice(i + 3, i + 3 + length);
-        var encodedSubr = decrypt(data, kCharStringsEncryptionKey, 4);
-        var str = decodeCharString(encodedSubr);
+      if ((glyphsSection || subrsSection) && c == "R") {
+        var data = eexec.slice(i + 3, i + 3 + length);
+        var encoded = decrypt(data, kCharStringsEncryptionKey, 4);
+        var str = decodeCharString(encoded);
 
-        subrs.push(str.charstring);
-        i += 3 + length;
-      } else if (inGlyphs && c == 0x52) {
-        length = parseInt(length);
-        var data = eexecString.slice(i + 3, i + 3 + length);
-        var encodedCharstring = decrypt(data, kCharStringsEncryptionKey, 4);
-        var str = decodeCharString(encodedCharstring);
-
-        glyphs.push({
+        if (glyphsSection) {
+          extracted.charstrings.push({
             glyph: glyph,
             data: str.charstring,
             lsb: str.lsb,
             width: str.width
-        });
-        i += 3 + length;
-      } else if (inGlyphs && c == 0x2F) {
+          });
+        } else {
+          extracted.subrs.push(str.charstring);
+        }
+        i += length + 3;
+      } else if (c == " " || c == "\n") {
+        length = parseInt(token);
         token = "";
-        glyph = "";
-
-        while ((c = eexecString[++i]) != 0x20)
-          glyph += String.fromCharCode(c);
-      } else if (!inSubrs && !inGlyphs && c == 0x2F && eexecString[i+1] == 0x53) {
-        while ((c = eexecString[++i]) != 0x20) {};
-        inSubrs = true;
-      } else if (c == 0x20) {
-        index = length;
-        length = token;
-        token = "";
-      } else if (c == 0x2F && eexecString[i+1] == 0x43 && eexecString[i+2] == 0x68) {
-        while ((c = eexecString[++i]) != 0x20) {};
-        inSubrs = false;
-        inGlyphs = true;
       } else {
-        token += String.fromCharCode(c);
+        token += c;
+        if (!glyphsSection) {
+          switch (token) {
+            case "/CharString":
+              glyphsSection = true;
+              break;
+            case "/Subrs":
+              subrsSection = true;
+              break;
+            case "/StdHW":
+              extracted.properties.stdHW = readNumberArray(eexecString, i + 2)[0];
+              break;
+            case "/StdVW":
+              extracted.properties.stdVW = readNumberArray(eexecString, i + 2)[0];
+              break;
+            case "/StemSnapH":
+              extracted.properties.stemSnapH = readNumberArray(eexecString, i + 2);
+              break;
+            case "/StemSnapV":
+              extracted.properties.stemSnapV = readNumberArray(eexecString, i + 2);
+              break;
+          }
+        } else if (c == "/") {
+          token = glyph = "";
+          while ((c = eexecString[++i]) != " ")
+            glyph += c;
+        }
       }
     }
-    return {
-      subrs: subrs,
-      charstrings: glyphs
+
+    return extracted;
+  },
+
+  this.extractFontHeader = function t1_extractFontProgram(stream) {
+    var headerString = "";
+    for (var i = 0; i < stream.length; i++)
+      headerString += String.fromCharCode(stream[i]);
+
+    var info = {
+      textMatrix: null
+    };
+
+    var token = "";
+    var count = headerString.length;
+    for (var i = 0; i < count; i++) {
+      var c = headerString[i];
+      if (c == " " || c == "\n") {
+        switch (token) {
+          case "/FontMatrix":
+            var matrix = readNumberArray(headerString, i + 1);
+
+            // The FontMatrix is in unitPerEm, so make it pixels
+            for (var j = 0; j < matrix.length; j++)
+              matrix[j] *= 1000;
+
+            // Make the angle into the right direction
+            matrix[2] *= -1;
+
+            info.textMatrix = matrix;
+            break;
+        }
+        token = "";
+      } else {
+        token += c;
+      }
     }
-  }
+
+    return info;
+  };
 };
 
 /**
@@ -1465,14 +1565,24 @@ var CFF = function(name, file, properties) {
   // Get the data block containing glyphs and subrs informations
   var length1 = file.dict.get("Length1");
   var length2 = file.dict.get("Length2");
-  file.skip(length1);
-  var eexecBlock = file.getBytes(length2);
+
+  var headerBlock = file.getBytes(length1);
+  var header = type1Parser.extractFontHeader(headerBlock);
+  for (var info in header)
+    properties[info] = header[info];
 
   // Decrypt the data blocks and retrieve it's content
+  var eexecBlock = file.getBytes(length2);
   var data = type1Parser.extractFontProgram(eexecBlock);
+  for (var info in data.properties)
+    properties[info] = data.properties[info];
 
-  this.charstrings = this.getOrderedCharStrings(data.charstrings);
-  this.data = this.wrap(name, this.charstrings, data.subrs, properties);
+  var charstrings = this.getOrderedCharStrings(data.charstrings);
+  var type2Charstrings = this.getType2Charstrings(charstrings);
+  var subrs = this.getType2Subrs(data.subrs);
+
+  this.charstrings = charstrings;
+  this.data = this.wrap(name, type2Charstrings, this.charstrings, subrs, properties);
 };
 
 CFF.prototype = {
@@ -1483,24 +1593,20 @@ CFF.prototype = {
     // If there is no object, just create an array saying that with another
     // offset byte.
     if (count == 0)
-      return [0x00, 0x00, 0x00];
+      return "\x00\x00\x00";
 
-    var data = [];
-    var bytes = FontsUtils.integerToBytes(count, 2);
-    for (var i = 0; i < bytes.length; i++)
-      data.push(bytes[i]);
+    var data = String.fromCharCode(count >> 8, count & 0xff);
 
     // Next byte contains the offset size use to reference object in the file
     // Actually we're using 0x04 to be sure to be able to store everything
     // without thinking of it while coding.
-    data.push(0x04);
+    data += "\x04";
 
     // Add another offset after this one because we need a new offset
     var relativeOffset = 1;
     for (var i = 0; i < count + 1; i++) {
-      var bytes = FontsUtils.integerToBytes(relativeOffset, 4);
-      for (var j = 0; j < bytes.length; j++)
-        data.push(bytes[j]);
+      data += String.fromCharCode(relativeOffset >> 24, relativeOffset >> 16,
+                                  relativeOffset >> 8, relativeOffset & 0xff);
 
       if (objects[i])
         relativeOffset += objects[i].length;
@@ -1508,17 +1614,22 @@ CFF.prototype = {
 
     for (var i =0; i < count; i++) {
       for (var j = 0; j < objects[i].length; j++)
-        data.push(isByte ? objects[i][j] : objects[i].charCodeAt(j));
+        data += isByte ? String.fromCharCode(objects[i][j]) : objects[i][j];
     }
     return data;
   },
 
   encodeNumber: function cff_encodeNumber(value) {
-    var x = 0;
     if (value >= -32768 && value <= 32767) {
-      return [ 28, value >> 8, value & 0xFF ];
+      return "\x1c" +
+             String.fromCharCode(value >> 8) +
+             String.fromCharCode(value & 0xFF);
     } else if (value >= (-2147483647-1) && value <= 2147483647) {
-      return [ 0xFF, value >> 24, Value >> 16, value >> 8, value & 0xFF ];
+      return "\xff" +
+             String.fromCharCode(value >> 24) +
+             String.fromCharCode(value >> 16) +
+             String.fromCharCode(value >> 8) +
+             String.fromCharCode(value & 0xFF);
     }
     error("Value: " + value + " is not allowed");
     return null;
@@ -1545,17 +1656,45 @@ CFF.prototype = {
     };
 
     charstrings.sort(function charstrings_sort(a, b) {
-      return a.unicode > b.unicode;
+      return a.unicode - b.unicode;
     });
     return charstrings;
   },
 
+  getType2Charstrings: function cff_getType2Charstrings(type1Charstrings) {
+    var type2Charstrings = [];
+	  var count = type1Charstrings.length;
+    for (var i = 0; i < count; i++) {
+      var charstring = type1Charstrings[i].charstring;
+      type2Charstrings.push(this.flattenCharstring(charstring.slice(), this.commandsMap));
+    }
+    return type2Charstrings;
+  },
+
+  getType2Subrs: function cff_getType2Charstrings(type1Subrs) {
+    var bias = 0;
+    var count = type1Subrs.length;
+    if (count < 1240)
+      bias = 107;
+    else if (count < 33900)
+      bias = 1131;
+    else
+      bias = 32768;
+
+    // Add a bunch of empty subrs to deal with the Type2 bias
+    var type2Subrs = [];
+    for (var i = 0; i < bias; i++)
+      type2Subrs.push([0x0B]);
+
+    for (var i = 0; i < count; i++)
+      type2Subrs.push(this.flattenCharstring(type1Subrs[i], this.commandsMap));
+
+    return type2Subrs;
+  },
+
   /*
    * Flatten the commands by interpreting the postscript code and replacing
    * every 'callsubr', 'callothersubr' by the real commands.
-   *
-   * TODO This function also do a string to command number transformation
-   * that can probably be avoided if the Type1 decodeCharstring code is smarter
    */
   commandsMap: {
     "hstem": 1,
@@ -1577,194 +1716,133 @@ CFF.prototype = {
     "hvcurveto": 31,
   },
 
-  flattenCharstring: function flattenCharstring(charstring) {
-    var i = 0;
-    while (true) {
-      var obj = charstring[i];
-      if (obj == undefined) {
-        error("unknow charstring command for " + i + " in " + charstring);
-      }
-      if (obj.charAt) {
-        switch (obj) {
-          case "endchar":
-          case "return":
-            // CharString is ready to be re-encode to commands number at this point
-            for (var j = 0; j < charstring.length; j++) {
-              var command = charstring[j];
-              if (parseFloat(command) == command) {
-                charstring.splice(j, 1, 28, command >> 8, command);
-                j+= 2;
-              } else if (command.charAt) {
-                var cmd = this.commandsMap[command];
-                if (!cmd)
-                  error("Unknow command: " + command);
+  flattenCharstring: function flattenCharstring(charstring, map) {
+    for (var i = 0; i < charstring.length; i++) {
+      var command = charstring[i];
+      if (command.charAt) {
+        var cmd = map[command];
+        assert(cmd, "Unknow command: " + command);
 
-                if (IsArray(cmd)) {
-                  charstring.splice(j, 1, cmd[0], cmd[1]);
-                  j += 1;
-                } else {
-                  charstring[j] = cmd;
-                }
-              }
-            }
-            return charstring;
-
-          default:
-            break;
+        if (IsArray(cmd)) {
+          charstring.splice(i++, 1, cmd[0], cmd[1]);
+        } else {
+          charstring[i] = cmd;
         }
+      } else {
+        charstring.splice(i, 1, 28, command >> 8, command & 0xff);
+        i+= 2;
       }
-      i++;
     }
-    error("failing with i = " + i + " in charstring:" + charstring + "(" + charstring.length + ")");
-    return [];
+    return charstring;
   },
 
-  wrap: function wrap(name, charstrings, subrs, properties) {
-    // Starts the conversion of the Type1 charstrings to Type2
-    var glyphs = [];
-	  var glyphsCount = charstrings.length;
-    for (var i = 0; i < glyphsCount; i++) {
-      var charstring = charstrings[i].charstring;
-      glyphs.push(this.flattenCharstring(charstring.slice()));
+  wrap: function wrap(name, glyphs, charstrings, subrs, properties) {
+    var fields = {
+      "header": "\x01\x00\x04\x04", // major version, minor version, header size, offset size
+
+      "names": this.createCFFIndexHeader([name]),
+
+      "topDict": (function topDict(self) {
+        return function() {
+          var dict =
+              "\x00\x01\x01\x01\x30" +
+              "\xf8\x1b\x00" + // version
+              "\xf8\x1b\x01" + // Notice
+              "\xf8\x1b\x02" + // FullName
+              "\xf8\x1b\x03" + // FamilyName
+              "\xf8\x1b\x04" +  // Weight
+              "\x1c\x00\x00\x10"; // Encoding
+
+          var boundingBox = properties.bbox;
+          for (var i = 0; i < boundingBox.length; i++)
+            dict += self.encodeNumber(boundingBox[i]);
+          dict += "\x05"; // FontBBox;
+
+          var offset = fields.header.length +
+                       fields.names.length +
+                       (dict.length + (4 + 4 + 7)) +
+                       fields.strings.length +
+                       fields.globalSubrs.length;
+          dict += self.encodeNumber(offset) + "\x0f"; // Charset
+
+          offset = offset + (glyphs.length * 2) + 1;
+          dict += self.encodeNumber(offset) + "\x11"; // Charstrings
+
+          dict += self.encodeNumber(fields.private.length);
+          var offset = offset + fields.charstrings.length;
+          dict += self.encodeNumber(offset) + "\x12"; // Private
+
+          return dict;
+        };
+      })(this),
+
+      "strings": (function strings(self) {
+        var strings = [
+          "Version 0.11",         // Version
+          "See original notice",  // Notice
+          name,                   // FullName
+          name,                   // FamilyName
+          "Medium"                // Weight
+        ];
+        return self.createCFFIndexHeader(strings);
+      })(this),
+
+      "globalSubrs": this.createCFFIndexHeader([]),
+
+      "charset": (function charset(self) {
+        var charset = "\x00"; // Encoding
+
+	      var count = glyphs.length;
+        for (var i = 0; i < count; i++) {
+          var index = CFFStrings.indexOf(charstrings[i].glyph.glyph);
+          // Some characters like asterikmath && circlecopyrt are missing from the
+          // original strings, for the moment let's map them to .notdef and see
+          // later if it cause any problems
+          if (index == -1)
+            index = 0;
+
+          charset += String.fromCharCode(index >> 8, index & 0xff);
+        }
+        return charset;
+      })(this),
+
+      "charstrings": this.createCFFIndexHeader([[0x8B, 0x0E]].concat(glyphs), true),
+
+      "private": (function(self) {
+        var data =
+            "\x8b\x14" + // defaultWidth
+            "\x8b\x15" + // nominalWidth
+            self.encodeNumber(properties.stdHW) + "\x0a" + // StdHW
+            self.encodeNumber(properties.stdVW) + "\x0b";  // StdVW
+
+        var stemH = properties.stemSnapH;
+        for (var i = 0; i < stemH.length; i++)
+          data += self.encodeNumber(stemH[i]);
+        data += "\x0c\x0c"; // StemSnapH
+
+        var stemV = properties.stemSnapV;
+        for (var i = 0; i < stemV.length; i++)
+          data += self.encodeNumber(stemV[i]);
+        data += "\x0c\x0d"; // StemSnapV
+
+        data += self.encodeNumber(data.length + 4) + "\x13"; // Subrs offset
+
+        return data;
+      })(this),
+
+      "localSubrs": this.createCFFIndexHeader(subrs, true)
+    };
+    fields.topDict = fields.topDict();
+
+
+    var cff = [];
+    for (var index in fields) {
+      var field = fields[index];
+      for (var i = 0; i < field.length; i++)
+        cff.push(field.charCodeAt(i));
     }
 
-    // Create a CFF font data
-    var cff = new Uint8Array(kMaxFontFileSize);
-    var currentOffset = 0;
-
-    // Font header (major version, minor version, header size, offset size)
-    var header = [0x01, 0x00, 0x04, 0x04];
-    currentOffset += header.length;
-    cff.set(header);
-
-    // Names Index
-    var nameIndex = this.createCFFIndexHeader([name]);
-    cff.set(nameIndex, currentOffset);
-    currentOffset += nameIndex.length;
-
-    // Calculate strings before writing the TopDICT index in order
-    // to calculate correct relative offsets for storing 'charset'
-    // and 'charstrings' data
-    var version = "";
-    var notice = "";
-    var fullName = "";
-    var familyName = "";
-    var weight = "";
-    var strings = [version, notice, fullName,
-                   familyName, weight];
-    var stringsIndex = this.createCFFIndexHeader(strings);
-    var stringsDataLength = stringsIndex.length;
-
-    // Create the global subroutines index
-    var globalSubrsIndex = this.createCFFIndexHeader([]);
-
-    // Fill the charset header (first byte is the encoding)
-    var charset = [0x00];
-    for (var i = 0; i < glyphsCount; i++) {
-      var index = CFFStrings.indexOf(charstrings[i].glyph);
-      if (index == -1)
-        index = CFFStrings.length + strings.indexOf(charstrings[i].glyph);
-      var bytes = FontsUtils.integerToBytes(index, 2);
-      charset.push(bytes[0]);
-      charset.push(bytes[1]);
-    }
-
-    var charstringsIndex = this.createCFFIndexHeader([[0x8B, 0x0E]].concat(glyphs), true);
-
-    //Top Dict Index
-    var topDictIndex = [
-      0x00, 0x01, 0x01, 0x01, 0x30,
-      248, 27, 0, // version
-      248, 28, 1, // Notice
-      248, 29, 2, // FullName
-      248, 30, 3, // FamilyName
-      248, 31, 4  // Weight
-    ];
-
-    var fontBBox = properties.bbox;
-    for (var i = 0; i < fontBBox.length; i++)
-      topDictIndex = topDictIndex.concat(this.encodeNumber(fontBBox[i]));
-    topDictIndex.push(5) // FontBBox;
-
-    var charsetOffset = currentOffset +
-                        (topDictIndex.length + (4 + 4 + 4 + 7)) +
-                        stringsIndex.length +
-                        globalSubrsIndex.length;
-    topDictIndex = topDictIndex.concat(this.encodeNumber(charsetOffset));
-    topDictIndex.push(15); // charset
-
-    topDictIndex = topDictIndex.concat([28, 0, 0, 16]) // Encoding
-
-    var charstringsOffset = charsetOffset + (glyphsCount * 2) + 1;
-    topDictIndex = topDictIndex.concat(this.encodeNumber(charstringsOffset));
-    topDictIndex.push(17); // charstrings
-
-    topDictIndex = topDictIndex.concat([28, 0, 55])
-    var privateOffset = charstringsOffset + charstringsIndex.length;
-    topDictIndex = topDictIndex.concat(this.encodeNumber(privateOffset));
-    topDictIndex.push(18); // Private
-
-    var indexes = [
-      topDictIndex, stringsIndex,
-      globalSubrsIndex, charset,
-      charstringsIndex
-    ];
-
-    for (var i = 0; i < indexes.length; i++) {
-      var index = indexes[i];
-      cff.set(index, currentOffset);
-      currentOffset += index.length;
-    }
-
-    // Private Data
-    var defaultWidth = this.encodeNumber(0);
-    var privateData = [].concat(
-      defaultWidth, [20],
-      [139, 21], // nominalWidth
-      [
-      119, 159, 248, 97, 159, 247, 87, 159, 6,
-      30, 10, 3, 150, 37, 255, 12, 9,
-      139, 12,
-      10, 172, 10,
-      172, 150, 143, 146, 150, 146, 12, 12,
-      247, 32, 11,
-      247, 10, 161, 147, 154, 150, 143, 12, 13,
-      139, 12, 14,
-      28, 0, 55, 19 // Subrs offset
-    ]);
-    cff.set(privateData, currentOffset);
-    currentOffset += privateData.length;
-
-    // Local Subrs
-    var flattenedSubrs = [];
-
-    var bias = 0;
-    var subrsCount = subrs.length;
-    if (subrsCount < 1240)
-      bias = 107;
-    else if (subrsCount < 33900)
-      bias = 1131;
-    else
-      bias = 32768;
-
-    // Add a bunch of empty subrs to deal with the Type2 bias
-    for (var i = 0; i < bias; i++)
-      flattenedSubrs.push([0x0B]);
-
-    for (var i = 0; i < subrsCount; i++) {
-      var subr = subrs[i];
-      flattenedSubrs.push(this.flattenCharstring(subr));
-    }
-
-    var subrsData = this.createCFFIndexHeader(flattenedSubrs, true);
-    cff.set(subrsData, currentOffset);
-    currentOffset += subrsData.length;
-
-    var fontData = [];
-    for (var i = 0; i < currentOffset; i++)
-      fontData.push(cff[i]);
-
-    return fontData;
+    return cff;
   }
 };
 
diff --git a/multi_page_viewer.js b/multi_page_viewer.js
index 180e715eb..01d7b4f6e 100644
--- a/multi_page_viewer.js
+++ b/multi_page_viewer.js
@@ -43,12 +43,12 @@ var PDFViewer = {
   lastPagesDrawn: [],
   
   visiblePages: function() {
-    const pageBottomMargin = 20;
+    const pageBottomMargin = 10;
     var windowTop = window.pageYOffset;
     var windowBottom = window.pageYOffset + window.innerHeight;
 
     var pageHeight, page;
-    var i, n = PDFViewer.numberOfPages, currentHeight = 0;
+    var i, n = PDFViewer.numberOfPages, currentHeight = pageBottomMargin;
     for (i = 1; i <= n; i++) {
       var page = PDFViewer.pdf.getPage(i);
       pageHeight = PDFViewer.pageHeight(page) + pageBottomMargin;
@@ -130,14 +130,7 @@ var PDFViewer = {
       var fonts = [];
       page.compile(gfx, fonts);
 
-      var loadFont = function() {
-        if (!FontLoader.bind(fonts)) {
-          pageTimeout = window.setTimeout(loadFont, 10);
-          return;
-        }
-        page.display(gfx);
-      }
-      loadFont();
+      FontLoader.bind(fonts, function() { page.display(gfx); });
     }
   },
   
@@ -197,17 +190,10 @@ var PDFViewer = {
       var fonts = [];
       page.compile(gfx, fonts);
 
-      var loadFont = function() {
-        if (!FontLoader.bind(fonts)) {
-          pageTimeout = window.setTimeout(loadFont, 10);
-          return;
-        }
-        page.display(gfx);
-      }
-      loadFont();
+      FontLoader.bind(fonts, function() { page.display(gfx); });
     }
   },
-  
+
   changeScale: function(num) {
     while (PDFViewer.element.hasChildNodes()) {
       PDFViewer.element.removeChild(PDFViewer.element.firstChild);
diff --git a/pdf.js b/pdf.js
index 3e3654087..814c99f75 100644
--- a/pdf.js
+++ b/pdf.js
@@ -3266,7 +3266,6 @@ var CanvasExtraState = (function() {
         this.fontSize = 0;
         this.textMatrix = IDENTITY_MATRIX;
         this.leading = 0;
-        this.colorSpace = null;
         // Current point (in user coordinates)
         this.x = 0;
         this.y = 0;
@@ -3277,6 +3276,9 @@ var CanvasExtraState = (function() {
         this.charSpace = 0;
         this.wordSpace = 0;
         this.textHScale = 100;
+        // Color spaces
+        this.fillColorSpace = null;
+        this.strokeColorSpace = null;
     }
     constructor.prototype = {
     };
@@ -3404,7 +3406,7 @@ var CanvasGraphics = (function() {
             BX: "beginCompat",
             EX: "endCompat",
         },
-      
+
         translateFont: function(fontDict, xref, resources) {
             var fd = fontDict.get("FontDescriptor");
             if (!fd)
@@ -3544,7 +3546,8 @@ var CanvasGraphics = (function() {
                 capHeight: descriptor.get("CapHeight"),
                 flags: descriptor.get("Flags"),
                 italicAngle: descriptor.get("ItalicAngle"),
-                fixedPitch: false
+                fixedPitch: false,
+                textMatrix: IDENTITY_MATRIX
             };
 
             return {
@@ -3869,6 +3872,11 @@ var CanvasGraphics = (function() {
             } else {
                 text = Fonts.charsToUnicode(text);
                 this.ctx.translate(this.current.x, -1 * this.current.y);
+
+                var font = Fonts.lookup(this.current.fontName);
+                if (font)
+                  this.ctx.transform.apply(this.ctx, font.properties.textMatrix);
+
                 this.ctx.fillText(text, 0, 0);
                 this.current.x += Fonts.measureText(text);
             }
@@ -3911,51 +3919,36 @@ var CanvasGraphics = (function() {
 
         // Color
         setStrokeColorSpace: function(space) {
-            // TODO real impl
+            this.current.strokeColorSpace = 
+                ColorSpace.parse(space, this.xref, this.res);
         },
         setFillColorSpace: function(space) {
-            // TODO real impl
-            if (space.name === "Pattern")
-                this.current.colorSpace = "Pattern";
-            else
-                this.current.colorSpace = "DeviceRGB";
+            this.current.fillColorSpace = 
+                ColorSpace.parse(space, this.xref, this.res);
         },
         setStrokeColor: function(/*...*/) {
-            // TODO real impl
-            if (1 === arguments.length) {
-                this.setStrokeGray.apply(this, arguments);
-            } else if (3 === arguments.length) {
-                this.setStrokeRGBColor.apply(this, arguments);
-            } else if (4 === arguments.length) {
-                this.setStrokeCMYKColor.apply(this, arguments);
-            }
+            var cs = this.getStrokeColorSpace();
+            var color = cs.getRgb(arguments);
+            this.setStrokeRGBColor.apply(this, color);
         },
         setStrokeColorN: function(/*...*/) {
             // TODO real impl
+            TODO("check for special color spaces");
             this.setStrokeColor.apply(this, arguments);
         },
         setFillColor: function(/*...*/) {
-            // TODO real impl
-            if (1 === arguments.length) {
-                this.setFillGray.apply(this, arguments);
-            } else if (3 === arguments.length) {
-                this.setFillRGBColor.apply(this, arguments);
-            } else if (4 === arguments.length) {
-                this.setFillCMYKColor.apply(this, arguments);
+            var cs = this.getFillColorSpace();
+            if (cs.name == "Pattern") {
+                TODO("implement Pattern fill");
+                return;
             }
+            var color = cs.getRgb(arguments);
+            this.setFillRGBColor.apply(this, color);
         },
         setFillColorN: function(/*...*/) {
-            // TODO real impl
-            var colorSpace = this.current.colorSpace;
-            if (!colorSpace) {
-                var stateStack = this.stateStack;
-                var i = stateStack.length - 1;
-                while (!colorSpace && i >= 0) {
-                    colorSpace = stateStack[i--].colorSpace;
-                }
-            }
+            var cs = this.getFillColorSpace();
 
-            if (this.current.colorSpace == "Pattern") {
+            if (cs.name == "Pattern") {
                 var patternName = arguments[0];
                 if (IsName(patternName)) {
                     var xref = this.xref;
@@ -4333,6 +4326,36 @@ var CanvasGraphics = (function() {
             var bi = (255 * (1 - Math.min(1, y * (1 - k) + k))) | 0;
             return "rgb("+ ri +","+ gi +","+ bi +")";
         },
+        getFillColorSpace: function() {
+            var cs = this.current.fillColorSpace;
+            if (cs)
+                return cs;
+
+            var states = this.stateStack;
+            var i = states.length - 1;
+            while (i >= 0 && !(cs = states[i].fillColorSpace))
+                --i;
+
+            if (cs)
+                return cs;
+            else
+                return new DeviceRgbCS();
+        },
+        getStrokeColorSpace: function() {
+            var cs = this.current.strokeColorSpace;
+            if (cs)
+                return cs;
+            
+            var states = this.stateStack;
+            var i = states.length - 1;
+            while (i >= 0 && !(cs = states[i].strokeColorSpace))
+                --i;
+
+            if (cs)
+                return cs;
+            else
+                return new DeviceRgbCS();
+        },
         // We generally keep the canvas context set for
         // nonzero-winding, and just set evenodd for the operations
         // that need them.
@@ -4350,51 +4373,90 @@ var CanvasGraphics = (function() {
 })();
 
 var ColorSpace = (function() {
-    function constructor(xref, cs) {
+    function constructor() {
+        error("should not call ColorSpace constructor");
+    };
+
+    constructor.parse = function colorspace_parse(cs, xref, res) {
+        if (IsName(cs)) {
+            var colorSpaces = res.get("ColorSpace");
+            if (colorSpaces) {
+                var refcs = colorSpaces.get(cs.name);
+                if (refcs)
+                    cs = refcs;
+            }
+        }
+            
+        cs = xref.fetchIfRef(cs);
+
         if (IsName(cs)) {
             var mode = cs.name;
             this.mode = mode;
+
             switch(mode) {
             case "DeviceGray":
             case "G":
-                this.numComps = 1;
+                return new DeviceGrayCS();
                 break;
             case "DeviceRGB":
-                this.numComps = 3;
+            case "RGB":
+                return new DeviceRgbCS();
                 break;
+            case "DeviceCMYK":
+            case "CMYK":
+                return new DeviceCmykCS();
+                break;
+            case "Pattern":
+                return new PatternCS(null);
+                break;
+            default:
+                error("unrecognized colorspace " + mode);
             }
-            TODO("fill in color space constructor");
         } else if (IsArray(cs)) {
             var mode = cs[0].name;
             this.mode = mode;
 
-            var stream = cs[1];
-            stream = xref.fetchIfRef(stream);
-
             switch (mode) {
             case "DeviceGray":
             case "G":
-                this.stream = stream;
-                this.dict = stream.dict;
-                this.numComps = 1;
+                return new DeviceGrayCS();
+                break;
+            case "DeviceRGB":
+            case "RGB":
+                return new DeviceRgbCS();
+                break;
+            case "DeviceCMYK":
+            case "CMYK":
+                return new DeviceCmykCS();
+                break;
+            case "CalGray":
+                return new DeviceGrayCS();
+                break;
+            case "CalRGB":
+                return new DeviceRgbCS();
                 break;
             case "ICCBased":
+                var stream = xref.fetchIfRef(cs[1]);
                 var dict = stream.dict;
-
-                this.stream = stream;
-                this.dict = dict;
-                this.numComps = dict.get("N");
+                var numComps = dict.get("N");
+                if (numComps == 1)
+                    return new DeviceGrayCS();
+                else if (numComps == 3)
+                    return new DeviceRgbCS();
+                else if (numComps == 4)
+                    return new DeviceCmykCS();
+                break;
+            case "Pattern":
+                return new PatternCS();
                 break;
             case "Indexed":
-                this.stream = stream;
-                this.dict = stream.dict;
-                var base = cs[1];
-                var hival = cs[2];
-                assertWellFormed(0 <= hival && hival <= 255, "hival in range");
-                var lookupTable = cs[3];
-                TODO("implement 'Indexed' color space");
-                this.numComps = 3; // HACK
-                break;
+                var base = ColorSpace.parse(cs[1], xref, res);
+                var hiVal = cs[2];
+                var lookup = xref.fetchIfRef(cs[3]);
+                return new IndexedCS(base, hiVal, lookup);
+            case "Lab":
+            case "Seperation":
+            case "DeviceN":
             default:
                 error("unrecognized color space object '"+ mode +"'");
             }
@@ -4403,9 +4465,137 @@ var ColorSpace = (function() {
         }
     };
 
+    return constructor;
+})();
+
+var PatternCS = (function() {
+    function constructor() {
+        this.name = "Pattern";
+    }
+    constructor.prototype = {};
+  
+    return constructor;
+})();
+
+var IndexedCS = (function() {
+    function constructor(base, highVal, lookup) {
+        this.name = "Indexed";
+        this.numComps = 1;
+        this.defaultColor = [0];
+
+        this.base = base;
+        var baseNumComps = base.numComps;
+        this.highVal = highVal;
+
+        var length = baseNumComps * highVal;
+        var lookupArray = new Uint8Array(length);
+        if (IsStream(lookup)) {
+            var bytes = lookup.getBytes(length);
+            lookupArray.set(bytes);
+        } else if (IsString(lookup)) {
+            for (var i = 0; i < length; ++i)
+                lookupArray[i] = lookup.charCodeAt(i);
+        } else {
+            error("Unrecognized lookup table");
+        }
+        this.lookup = lookupArray;
+    }
+
     constructor.prototype = {
+        getRgb: function graycs_getRgb(color) {
+            var lookup = this.lookup;
+            var base = this.base;
+            var numComps = base.numComps;
+            
+            var c = [];
+            for (var i = 0; i < numComps; ++i)
+                c.push(lookup[i])
+            return this.base.getRgb(c);
+        },
+        getRgbBuffer: function graycs_getRgbBuffer(input) {
+            var base = this.base;
+            var numComps = base.numComps;
+            var lookup = this.lookup;
+            var length = input.length;
+
+            var baseBuf = new Uint8Array(length * numComps);
+            var baseBufPos = 0;
+            for (var i = 0; i < length; ++i) {
+                var lookupPos = input[i];
+                for (var j = 0; j < numComps ; ++j) {
+                    baseBuf[baseBufPos++] = lookup[lookupPos + j];
+                }
+            }
+            
+            return base.getRgbBuffer(baseBuf);
+        }
+    };
+    return constructor;
+})();
+
+var DeviceGrayCS = (function() {
+    function constructor() {
+        this.name = "DeviceGray";
+        this.numComps = 1;
+        this.defaultColor = [0];
     };
 
+    constructor.prototype = {
+        getRgb: function graycs_getRgb(color) {
+            var c = color[0];
+            return [c, c, c];
+        },
+        getRgbBuffer: function graycs_getRgbBuffer(input) {
+            var length = input.length;
+            var rgbBuf = new Uint8Array(length);
+            for (var i = 0, j = 0; i < length; ++i) {
+                var c = input[i];
+                rgbBuf[j++] = c;
+                rgbBuf[j++] = c;
+                rgbBuf[j++] = c;
+            }
+            return rgbBuf;
+        }
+    };
+    return constructor;
+})();
+
+var DeviceRgbCS = (function() {
+    function constructor() {
+        this.name = "DeviceRGB";
+        this.numComps = 3;
+        this.defaultColor = [0, 0, 0];
+    }
+    constructor.prototype = {
+        getRgb: function graycs_getRgb(color) {
+            return color;
+        },
+        getRgbBuffer: function graycs_getRgbBuffer(input) {
+            return input;
+        }
+    };
+    return constructor;
+})();
+
+var DeviceCmykCS = (function() {
+    function constructor() {
+        this.name = "DeviceCMYK";
+        this.numComps = 4;
+        this.defaultColor = [0, 0, 0, 1];
+    }
+    constructor.prototype = {
+        getRgb: function graycs_getRgb(color) {
+            var c = color[0], y = color[1], m = color[2], k = color[3];
+            var ri = (1 - Math.min(1, c * (1 - k) + k)) | 0;
+            var gi = (1 - Math.min(1, m * (1 - k) + k)) | 0;
+            var bi = (1 - Math.min(1, y * (1 - k) + k)) | 0;
+            return [ri, gi, bi];
+        },
+        getRgbBuffer: function graycs_getRgbBuffer(colorBuf) {
+            error("conversion from rgb to cmyk not implemented for images");
+            return colorBuf;
+        }
+    };
     return constructor;
 })();
 
@@ -4443,11 +4633,8 @@ var PDFImage = (function() {
         }
         this.bpc = bitsPerComponent;
 
-        var colorSpaces = res.get("ColorSpace");
-        var csStream = xref.fetchIfRef(dict.get2("ColorSpace", "CS"));
-        if (IsName(csStream) && inline)
-            csStream = colorSpaces.get(csStream);
-        this.colorSpace = new ColorSpace(xref, csStream);
+        var colorSpace = dict.get2("ColorSpace", "CS");
+        this.colorSpace = ColorSpace.parse(colorSpace, xref, res);
 
         this.numComps = this.colorSpace.numComps;
         this.decode = dict.get2("Decode", "D");
@@ -4523,7 +4710,7 @@ var PDFImage = (function() {
                     output[i] = Math.round(255 * ret / ((1 << bpc) - 1));
                 }
             }
-            return output;
+            return this.colorSpace.getRbaBuffer(output);
         },
         getOpacity: function getOpacity() {
             var smask = this.smask;
diff --git a/test/test.py b/test/test.py
index a91d70848..52e91476a 100644
--- a/test/test.py
+++ b/test/test.py
@@ -16,6 +16,9 @@ REFDIR = 'ref'
 TMPDIR = 'tmp'
 VERBOSE = False
 
+SERVER_HOST = "localhost"
+SERVER_PORT = 8080
+
 class TestOptions(OptionParser):
     def __init__(self, **kwargs):
         OptionParser.__init__(self, **kwargs)
@@ -41,7 +44,7 @@ class TestOptions(OptionParser):
         if options.browser and options.browserManifestFile:
             print "Warning: ignoring browser argument since manifest file was also supplied"
         if not options.browser and not options.browserManifestFile:
-            self.error("No test browsers found. Use --browserManifest or --browser args.")
+            print "No browser arguments supplied, so just starting server on port %s." % SERVER_PORT
         return options
         
 def prompt(question):
@@ -295,7 +298,9 @@ def setUp(options):
         testBrowsers = makeBrowserCommands(options.browserManifestFile)
     elif options.browser:
         testBrowsers = [makeBrowserCommand({"path":options.browser, "name":None})]
-    assert len(testBrowsers) > 0
+
+    if options.browserManifestFile or options.browser:
+        assert len(testBrowsers) > 0
 
     with open(options.manifestFile) as mf:
         manifestList = json.load(mf)
@@ -320,9 +325,11 @@ def startBrowsers(browsers, options):
     for b in browsers:
         b.setup()
         print 'Launching', b.name
+        host = 'http://%s:%s' % (SERVER_HOST, SERVER_PORT) 
+        path = '/test/test_slave.html?'
         qs = 'browser='+ urllib.quote(b.name) +'&manifestFile='+ urllib.quote(options.manifestFile)
         qs += '&path=' + b.path
-        b.start('http://localhost:8080/test/test_slave.html?'+ qs)
+        b.start(host + path + qs)
 
 def teardownBrowsers(browsers):
     for b in browsers:
@@ -476,7 +483,8 @@ def maybeUpdateRefImages(options, browser):
                 print 'done'
 
 def startReftest(browser):
-    url = "http://127.0.0.1:8080/test/resources/reftest-analyzer.xhtml"
+    url = "http://%s:%s" % (SERVER_HOST, SERVER_PORT)
+    url += "/test/resources/reftest-analyzer.xhtml"
     url += "#web=/test/eq.log"
     try:
         browser.setup()
@@ -487,20 +495,8 @@ def startReftest(browser):
         teardownBrowsers([browser])
     print "Completed reftest usage."
 
-def main():
+def runTests(options, browsers):
     t1 = time.time()
-    optionParser = TestOptions()
-    options, args = optionParser.parse_args()
-    options = optionParser.verifyOptions(options)
-    if options == None:
-        sys.exit(1)
-
-    httpd = TestServer(('127.0.0.1', 8080), PDFTestHandler)
-    httpd_thread = threading.Thread(target=httpd.serve_forever)
-    httpd_thread.setDaemon(True)
-    httpd_thread.start()
-
-    browsers = setUp(options)
     try:
         startBrowsers(browsers, options)
         while not State.done:
@@ -517,5 +513,26 @@ def main():
         print "\nStarting reftest harness to examine %d eq test failures." % State.numEqFailures
         startReftest(browsers[0])
 
+def main():
+    optionParser = TestOptions()
+    options, args = optionParser.parse_args()
+    options = optionParser.verifyOptions(options)
+    if options == None:
+        sys.exit(1)
+
+    httpd = TestServer((SERVER_HOST, SERVER_PORT), PDFTestHandler)
+    httpd_thread = threading.Thread(target=httpd.serve_forever)
+    httpd_thread.setDaemon(True)
+    httpd_thread.start()
+
+    browsers = setUp(options)
+    if len(browsers) > 0:
+        runTests(options, browsers)
+    else:
+        # just run the server
+        print "Running HTTP server. Press Ctrl-C to quit."
+        while True:
+            time.sleep(1)
+
 if __name__ == '__main__':
     main()
diff --git a/test/test_slave.html b/test/test_slave.html
index 0a330e703..3180418fa 100644
--- a/test/test_slave.html
+++ b/test/test_slave.html
@@ -115,25 +115,18 @@ function nextPage() {
     failure = 'page setup: '+ e.toString();
   }
 
-  var fontLoaderTimer = null;
-  function checkFontsLoaded() {
+  if (!failure) {
     try {
-      if (!FontLoader.bind(fonts)) {
-        fontLoaderTimer = window.setTimeout(checkFontsLoaded, 10);
-        return;
-      }
+      FontLoader.bind(fonts, function() { snapshotCurrentPage(gfx); });
     } catch(e) {
       failure = 'fonts: '+ e.toString();
     }
-    snapshotCurrentPage(gfx);
   }
 
   if (failure) {
-    // Skip font loading if there was a failure, since the fonts might
-    // be in an inconsistent state.
+    // Skip right to snapshotting if there was a failure, since the
+    // fonts might be in an inconsistent state.
     snapshotCurrentPage(gfx);
-  } else {
-    checkFontsLoaded();
   }
 }
 
diff --git a/utils/fonts_utils.js b/utils/fonts_utils.js
index 532853460..bc0a8544c 100644
--- a/utils/fonts_utils.js
+++ b/utils/fonts_utils.js
@@ -12,8 +12,6 @@
  * CharString or to understand the structure of the CFF format.
  */
 
-"use strict";
-
 /**
  * Build a charset by assigning the glyph name and the human readable form
  * of the glyph data.
@@ -380,6 +378,9 @@ var Type2Parser = function(aFilePath) {
  * writeToFile(fontData, "/tmp/pdf.js." + fontCount + ".cff");
  */
 function writeToFile(aBytes, aFilePath) {
+  if (!("netscape" in window))
+    return;
+
   netscape.security.PrivilegeManager.enablePrivilege("UniversalXPConnect");
   var Cc = Components.classes,
       Ci = Components.interfaces;
@@ -388,7 +389,7 @@ function writeToFile(aBytes, aFilePath) {
 
   var stream = Cc["@mozilla.org/network/file-output-stream;1"]
                  .createInstance(Ci.nsIFileOutputStream);
-  stream.init(file, 0x04 | 0x08 | 0x20, 600, 0);
+  stream.init(file, 0x04 | 0x08 | 0x20, 0x180, 0);
 
   var bos = Cc["@mozilla.org/binaryoutputstream;1"]
               .createInstance(Ci.nsIBinaryOutputStream);
diff --git a/viewer.js b/viewer.js
index 38b0537b1..4071151aa 100644
--- a/viewer.js
+++ b/viewer.js
@@ -3,7 +3,7 @@
 
 "use strict";
 
-var pdfDocument, canvas, pageScale, pageDisplay, pageNum, numPages, pageTimeout;
+var pdfDocument, canvas, pageScale, pageDisplay, pageNum, numPages;
 function load(userInput) {
     canvas = document.getElementById("canvas");
     canvas.mozOpaque = true;
@@ -53,8 +53,6 @@ function gotoPage(num) {
 }
 
 function displayPage(num) {
-    window.clearTimeout(pageTimeout);
-
     document.getElementById("pageNumber").value = num;
 
     var t0 = Date.now();
@@ -82,22 +80,18 @@ function displayPage(num) {
     page.compile(gfx, fonts);
     var t2 = Date.now();
 
-    function loadFont() {
-      if (!FontLoader.bind(fonts)) {
-        pageTimeout = window.setTimeout(loadFont, 10);
-        return;
-      }
+    function displayPage() {
+        var t3 = Date.now();
 
-      var t3 = Date.now();
+        page.display(gfx);
 
-      page.display(gfx);
+        var t4 = Date.now();
 
-      var t4 = Date.now();
+        var infoDisplay = document.getElementById("info");
+        infoDisplay.innerHTML = "Time to load/compile/fonts/render: "+ (t1 - t0) + "/" + (t2 - t1) + "/" + (t3 - t2) + "/" + (t4 - t3) + " ms";
+    }
 
-      var infoDisplay = document.getElementById("info");
-      infoDisplay.innerHTML = "Time to load/compile/fonts/render: "+ (t1 - t0) + "/" + (t2 - t1) + "/" + (t3 - t2) + "/" + (t4 - t3) + " ms";
-    };
-    loadFont();
+    FontLoader.bind(fonts, displayPage);
 }
 
 function nextPage() {