Merge upstream and change test pdf file.

Makefile

@@ -64,6 +64,7 @@ bundle: | $(BUILD_DIR)
 	@cd src; \
 	cat $(PDF_JS_FILES) > all_files.tmp; \
 	sed '/PDFJSSCRIPT_INCLUDE_ALL/ r all_files.tmp' pdf.js > ../$(BUILD_TARGET); \
+	sed -i '' "s/PDFJSSCRIPT_BUNDLE_VER/`git log --format="%H" -n 1`/" ../$(BUILD_TARGET); \
 	rm -f *.tmp; \
 	cd ..
 

README.md

@@ -95,9 +95,17 @@ workings of PDF and pdf.js:
 ## Contributing
 
 pdf.js is a community-driven project, so contributors are always welcome. 
-Simply fork our repo and contribute away. A great place to start is our
-[open issues](https://github.com/mozilla/pdf.js/issues). For better consistency and 
-long-term stability, please do look around the code and try to follow our conventions.
+Simply fork our repo and contribute away. Good starting places for picking
+a bug are the top error messages and TODOs in our corpus report:
+
++ http://people.mozilla.com/~bdahl/corpusreport/test/ref/
+
+and of course our open Github issues:
+
++ https://github.com/mozilla/pdf.js/issues 
+
+For better consistency and long-term stability, please do look around the 
+code and try to follow our conventions.
 More information about the contributor process can be found on the 
 [contributor wiki page](https://github.com/mozilla/pdf.js/wiki/Contributing).
 
@@ -152,9 +160,9 @@ See the bot repo for details:
 
 ## Additional resources
 
-Our demo site is here:
+Gallery of user projects and modifications:
 
-+ http://mozilla.github.com/pdf.js/web/viewer.html
++ https://github.com/mozilla/pdf.js/wiki/Gallery-of-user-projects-and-modifications
 
 You can read more about pdf.js here:
 

extensions/firefox/install.rdf

@@ -12,7 +12,7 @@
       <Description>
        <em:id>{ec8030f7-c20a-464f-9b0e-13a3a9e97384}</em:id>
        <em:minVersion>6.0</em:minVersion>
-       <em:maxVersion>10.0.*</em:maxVersion>
+       <em:maxVersion>11.0.*</em:maxVersion>
      </Description>
     </em:targetApplication>
     <em:bootstrap>true</em:bootstrap>

external/jasmine/MIT.LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008-2011 Pivotal Labs
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

external/jasmine/jasmine-html.js

@@ -0,0 +1,676 @@
+jasmine.HtmlReporterHelpers = {};
+
+jasmine.HtmlReporterHelpers.createDom = function(type, attrs, childrenVarArgs) {
+  var el = document.createElement(type);
+
+  for (var i = 2; i < arguments.length; i++) {
+    var child = arguments[i];
+
+    if (typeof child === 'string') {
+      el.appendChild(document.createTextNode(child));
+    } else {
+      if (child) {
+        el.appendChild(child);
+      }
+    }
+  }
+
+  for (var attr in attrs) {
+    if (attr == "className") {
+      el[attr] = attrs[attr];
+    } else {
+      el.setAttribute(attr, attrs[attr]);
+    }
+  }
+
+  return el;
+};
+
+jasmine.HtmlReporterHelpers.getSpecStatus = function(child) {
+  var results = child.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.skipped) {
+    status = 'skipped';
+  }
+
+  return status;
+};
+
+jasmine.HtmlReporterHelpers.appendToSummary = function(child, childElement) {
+  var parentDiv = this.dom.summary;
+  var parentSuite = (typeof child.parentSuite == 'undefined') ? 'suite' : 'parentSuite';
+  var parent = child[parentSuite];
+
+  if (parent) {
+    if (typeof this.views.suites[parent.id] == 'undefined') {
+      this.views.suites[parent.id] = new jasmine.HtmlReporter.SuiteView(parent, this.dom, this.views);
+    }
+    parentDiv = this.views.suites[parent.id].element;
+  }
+
+  parentDiv.appendChild(childElement);
+};
+
+
+jasmine.HtmlReporterHelpers.addHelpers = function(ctor) {
+  for(var fn in jasmine.HtmlReporterHelpers) {
+    ctor.prototype[fn] = jasmine.HtmlReporterHelpers[fn];
+  }
+};
+
+jasmine.HtmlReporter = function(_doc) {
+  var self = this;
+  var doc = _doc || window.document;
+
+  var reporterView;
+
+  var dom = {};
+
+  // Jasmine Reporter Public Interface
+  self.logRunningSpecs = false;
+
+  self.reportRunnerStarting = function(runner) {
+    var specs = runner.specs() || [];
+
+    if (specs.length == 0) {
+      return;
+    }
+
+    createReporterDom(runner.env.versionString());
+    doc.body.appendChild(dom.reporter);
+
+    reporterView = new jasmine.HtmlReporter.ReporterView(dom);
+    reporterView.addSpecs(specs, self.specFilter);
+  };
+
+  self.reportRunnerResults = function(runner) {
+    reporterView.complete();
+  };
+
+  self.reportSuiteResults = function(suite) {
+    reporterView.suiteComplete(suite);
+  };
+
+  self.reportSpecStarting = function(spec) {
+    if (self.logRunningSpecs) {
+      self.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');
+    }
+  };
+
+  self.reportSpecResults = function(spec) {
+    reporterView.specComplete(spec);
+  };
+
+  self.log = function() {
+    var console = jasmine.getGlobal().console;
+    if (console && console.log) {
+      if (console.log.apply) {
+        console.log.apply(console, arguments);
+      } else {
+        console.log(arguments); // ie fix: console.log.apply doesn't exist on ie
+      }
+    }
+  };
+
+  self.specFilter = function(spec) {
+    if (!focusedSpecName()) {
+      return true;
+    }
+
+    return spec.getFullName().indexOf(focusedSpecName()) === 0;
+  };
+
+  return self;
+
+  function focusedSpecName() {
+    var specName;
+
+    (function memoizeFocusedSpec() {
+      if (specName) {
+        return;
+      }
+
+      var paramMap = [];
+      var params = doc.location.search.substring(1).split('&');
+
+      for (var i = 0; i < params.length; i++) {
+        var p = params[i].split('=');
+        paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
+      }
+
+      specName = paramMap.spec;
+    })();
+
+    return specName;
+  }
+
+  function createReporterDom(version) {
+    dom.reporter = self.createDom('div', { id: 'HTMLReporter', className: 'jasmine_reporter' },
+      dom.banner = self.createDom('div', { className: 'banner' },
+        self.createDom('span', { className: 'title' }, "Jasmine "),
+        self.createDom('span', { className: 'version' }, version)),
+
+      dom.symbolSummary = self.createDom('ul', {className: 'symbolSummary'}),
+      dom.alert = self.createDom('div', {className: 'alert'}),
+      dom.results = self.createDom('div', {className: 'results'},
+        dom.summary = self.createDom('div', { className: 'summary' }),
+        dom.details = self.createDom('div', { id: 'details' }))
+    );
+  }
+};
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter);jasmine.HtmlReporterHelpers = {};
+
+jasmine.HtmlReporterHelpers.createDom = function(type, attrs, childrenVarArgs) {
+  var el = document.createElement(type);
+
+  for (var i = 2; i < arguments.length; i++) {
+    var child = arguments[i];
+
+    if (typeof child === 'string') {
+      el.appendChild(document.createTextNode(child));
+    } else {
+      if (child) {
+        el.appendChild(child);
+      }
+    }
+  }
+
+  for (var attr in attrs) {
+    if (attr == "className") {
+      el[attr] = attrs[attr];
+    } else {
+      el.setAttribute(attr, attrs[attr]);
+    }
+  }
+
+  return el;
+};
+
+jasmine.HtmlReporterHelpers.getSpecStatus = function(child) {
+  var results = child.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.skipped) {
+    status = 'skipped';
+  }
+
+  return status;
+};
+
+jasmine.HtmlReporterHelpers.appendToSummary = function(child, childElement) {
+  var parentDiv = this.dom.summary;
+  var parentSuite = (typeof child.parentSuite == 'undefined') ? 'suite' : 'parentSuite';
+  var parent = child[parentSuite];
+
+  if (parent) {
+    if (typeof this.views.suites[parent.id] == 'undefined') {
+      this.views.suites[parent.id] = new jasmine.HtmlReporter.SuiteView(parent, this.dom, this.views);
+    }
+    parentDiv = this.views.suites[parent.id].element;
+  }
+
+  parentDiv.appendChild(childElement);
+};
+
+
+jasmine.HtmlReporterHelpers.addHelpers = function(ctor) {
+  for(var fn in jasmine.HtmlReporterHelpers) {
+    ctor.prototype[fn] = jasmine.HtmlReporterHelpers[fn];
+  }
+};
+
+jasmine.HtmlReporter.ReporterView = function(dom) {
+  this.startedAt = new Date();
+  this.runningSpecCount = 0;
+  this.completeSpecCount = 0;
+  this.passedCount = 0;
+  this.failedCount = 0;
+  this.skippedCount = 0;
+
+  this.createResultsMenu = function() {
+    this.resultsMenu = this.createDom('span', {className: 'resultsMenu bar'},
+      this.summaryMenuItem = this.createDom('a', {className: 'summaryMenuItem', href: "#"}, '0 specs'),
+      ' | ',
+      this.detailsMenuItem = this.createDom('a', {className: 'detailsMenuItem', href: "#"}, '0 failing'));
+
+    this.summaryMenuItem.onclick = function() {
+      dom.reporter.className = dom.reporter.className.replace(/ showDetails/g, '');
+    };
+
+    this.detailsMenuItem.onclick = function() {
+      showDetails();
+    };
+  };
+
+  this.addSpecs = function(specs, specFilter) {
+    this.totalSpecCount = specs.length;
+
+    this.views = {
+      specs: {},
+      suites: {}
+    };
+
+    for (var i = 0; i < specs.length; i++) {
+      var spec = specs[i];
+      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom, this.views);
+      if (specFilter(spec)) {
+        this.runningSpecCount++;
+      }
+    }
+  };
+
+  this.specComplete = function(spec) {
+    this.completeSpecCount++;
+
+    if (isUndefined(this.views.specs[spec.id])) {
+      this.views.specs[spec.id] = new jasmine.HtmlReporter.SpecView(spec, dom);
+    }
+
+    var specView = this.views.specs[spec.id];
+
+    switch (specView.status()) {
+      case 'passed':
+        this.passedCount++;
+        break;
+
+      case 'failed':
+        this.failedCount++;
+        break;
+
+      case 'skipped':
+        this.skippedCount++;
+        break;
+    }
+
+    specView.refresh();
+    this.refresh();
+  };
+
+  this.suiteComplete = function(suite) {
+    var suiteView = this.views.suites[suite.id];
+    if (isUndefined(suiteView)) {
+      return;
+    }
+    suiteView.refresh();
+  };
+
+  this.refresh = function() {
+
+    if (isUndefined(this.resultsMenu)) {
+      this.createResultsMenu();
+    }
+
+    // currently running UI
+    if (isUndefined(this.runningAlert)) {
+      this.runningAlert = this.createDom('a', {href: "?", className: "runningAlert bar"});
+      dom.alert.appendChild(this.runningAlert);
+    }
+    this.runningAlert.innerHTML = "Running " + this.completeSpecCount + " of " + specPluralizedFor(this.totalSpecCount);
+
+    // skipped specs UI
+    if (isUndefined(this.skippedAlert)) {
+      this.skippedAlert = this.createDom('a', {href: "?", className: "skippedAlert bar"});
+    }
+
+    this.skippedAlert.innerHTML = "Skipping " + this.skippedCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all";
+
+    if (this.skippedCount === 1 && isDefined(dom.alert)) {
+      dom.alert.appendChild(this.skippedAlert);
+    }
+
+    // passing specs UI
+    if (isUndefined(this.passedAlert)) {
+      this.passedAlert = this.createDom('span', {href: "?", className: "passingAlert bar"});
+    }
+    this.passedAlert.innerHTML = "Passing " + specPluralizedFor(this.passedCount);
+
+    // failing specs UI
+    if (isUndefined(this.failedAlert)) {
+      this.failedAlert = this.createDom('span', {href: "?", className: "failingAlert bar"});
+    }
+    this.failedAlert.innerHTML = "Failing " + specPluralizedFor(this.failedCount);
+
+    if (this.failedCount === 1 && isDefined(dom.alert)) {
+      dom.alert.appendChild(this.failedAlert);
+      dom.alert.appendChild(this.resultsMenu);
+    }
+
+    // summary info
+    this.summaryMenuItem.innerHTML = "" + specPluralizedFor(this.runningSpecCount);
+    this.detailsMenuItem.innerHTML = "" + this.failedCount + " failing";
+  };
+
+  this.complete = function() {
+    dom.alert.removeChild(this.runningAlert);
+
+    this.skippedAlert.innerHTML = "Ran " + this.runningSpecCount + " of " + specPluralizedFor(this.totalSpecCount) + " - run all";
+
+    if (this.failedCount === 0) {
+      dom.alert.appendChild(this.createDom('span', {className: 'passingAlert bar'}, "Passing " + specPluralizedFor(this.passedCount)));
+    } else {
+      showDetails();
+    }
+
+    dom.banner.appendChild(this.createDom('span', {className: 'duration'}, "finished in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s"));
+  };
+
+  return this;
+
+  function showDetails() {
+    if (dom.reporter.className.search(/showDetails/) === -1) {
+      dom.reporter.className += " showDetails";
+    }
+  }
+
+  function isUndefined(obj) {
+    return typeof obj === 'undefined';
+  }
+
+  function isDefined(obj) {
+    return !isUndefined(obj);
+  }
+
+  function specPluralizedFor(count) {
+    var str = count + " spec";
+    if (count > 1) {
+      str += "s"
+    }
+    return str;
+  }
+
+};
+
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.ReporterView);
+
+
+jasmine.HtmlReporter.SpecView = function(spec, dom, views) {
+  this.spec = spec;
+  this.dom = dom;
+  this.views = views;
+
+  this.symbol = this.createDom('li', { className: 'pending' });
+  this.dom.symbolSummary.appendChild(this.symbol);
+
+  this.summary = this.createDom('div', { className: 'specSummary' },
+      this.createDom('a', {
+        className: 'description',
+        href: '?spec=' + encodeURIComponent(this.spec.getFullName()),
+        title: this.spec.getFullName()
+      }, this.spec.description)
+  );
+
+  this.detail = this.createDom('div', { className: 'specDetail' },
+      this.createDom('a', {
+        className: 'description',
+        href: '?spec=' + encodeURIComponent(this.spec.getFullName()),
+        title: this.spec.getFullName()
+      }, this.spec.getFullName())
+  );
+};
+
+jasmine.HtmlReporter.SpecView.prototype.status = function() {
+  return this.getSpecStatus(this.spec);
+};
+
+jasmine.HtmlReporter.SpecView.prototype.refresh = function() {
+  this.symbol.className = this.status();
+
+  switch (this.status()) {
+    case 'skipped':
+      break;
+
+    case 'passed':
+      this.appendSummaryToSuiteDiv();
+      break;
+
+    case 'failed':
+      this.appendSummaryToSuiteDiv();
+      this.appendFailureDetail();
+      break;
+  }
+};
+
+jasmine.HtmlReporter.SpecView.prototype.appendSummaryToSuiteDiv = function() {
+  this.summary.className += ' ' + this.status();
+  this.appendToSummary(this.spec, this.summary);
+};
+
+jasmine.HtmlReporter.SpecView.prototype.appendFailureDetail = function() {
+  this.detail.className += ' ' + this.status();
+
+  var resultItems = this.spec.results().getItems();
+  var messagesDiv = this.createDom('div', { className: 'messages' });
+
+  for (var i = 0; i < resultItems.length; i++) {
+    var result = resultItems[i];
+
+    if (result.type == 'log') {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));
+    } else if (result.type == 'expect' && result.passed && !result.passed()) {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
+
+      if (result.trace.stack) {
+        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
+      }
+    }
+  }
+
+  if (messagesDiv.childNodes.length > 0) {
+    this.detail.appendChild(messagesDiv);
+    this.dom.details.appendChild(this.detail);
+  }
+};
+
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SpecView);jasmine.HtmlReporter.SuiteView = function(suite, dom, views) {
+  this.suite = suite;
+  this.dom = dom;
+  this.views = views;
+
+  this.element = this.createDom('div', { className: 'suite' },
+      this.createDom('a', { className: 'description', href: '?spec=' + encodeURIComponent(this.suite.getFullName()) }, this.suite.description)
+  );
+
+  this.appendToSummary(this.suite, this.element);
+};
+
+jasmine.HtmlReporter.SuiteView.prototype.status = function() {
+  return this.getSpecStatus(this.suite);
+};
+
+jasmine.HtmlReporter.SuiteView.prototype.refresh = function() {
+  this.element.className += " " + this.status();
+};
+
+jasmine.HtmlReporterHelpers.addHelpers(jasmine.HtmlReporter.SuiteView);
+
+/* @deprecated Use jasmine.HtmlReporter instead
+ */
+jasmine.TrivialReporter = function(doc) {
+  this.document = doc || document;
+  this.suiteDivs = {};
+  this.logRunningSpecs = false;
+};
+
+jasmine.TrivialReporter.prototype.createDom = function(type, attrs, childrenVarArgs) {
+  var el = document.createElement(type);
+
+  for (var i = 2; i < arguments.length; i++) {
+    var child = arguments[i];
+
+    if (typeof child === 'string') {
+      el.appendChild(document.createTextNode(child));
+    } else {
+      if (child) { el.appendChild(child); }
+    }
+  }
+
+  for (var attr in attrs) {
+    if (attr == "className") {
+      el[attr] = attrs[attr];
+    } else {
+      el.setAttribute(attr, attrs[attr]);
+    }
+  }
+
+  return el;
+};
+
+jasmine.TrivialReporter.prototype.reportRunnerStarting = function(runner) {
+  var showPassed, showSkipped;
+
+  this.outerDiv = this.createDom('div', { id: 'TrivialReporter', className: 'jasmine_reporter' },
+      this.createDom('div', { className: 'banner' },
+        this.createDom('div', { className: 'logo' },
+            this.createDom('span', { className: 'title' }, "Jasmine"),
+            this.createDom('span', { className: 'version' }, runner.env.versionString())),
+        this.createDom('div', { className: 'options' },
+            "Show ",
+            showPassed = this.createDom('input', { id: "__jasmine_TrivialReporter_showPassed__", type: 'checkbox' }),
+            this.createDom('label', { "for": "__jasmine_TrivialReporter_showPassed__" }, " passed "),
+            showSkipped = this.createDom('input', { id: "__jasmine_TrivialReporter_showSkipped__", type: 'checkbox' }),
+            this.createDom('label', { "for": "__jasmine_TrivialReporter_showSkipped__" }, " skipped")
+            )
+          ),
+
+      this.runnerDiv = this.createDom('div', { className: 'runner running' },
+          this.createDom('a', { className: 'run_spec', href: '?' }, "run all"),
+          this.runnerMessageSpan = this.createDom('span', {}, "Running..."),
+          this.finishedAtSpan = this.createDom('span', { className: 'finished-at' }, ""))
+      );
+
+  this.document.body.appendChild(this.outerDiv);
+
+  var suites = runner.suites();
+  for (var i = 0; i < suites.length; i++) {
+    var suite = suites[i];
+    var suiteDiv = this.createDom('div', { className: 'suite' },
+        this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, "run"),
+        this.createDom('a', { className: 'description', href: '?spec=' + encodeURIComponent(suite.getFullName()) }, suite.description));
+    this.suiteDivs[suite.id] = suiteDiv;
+    var parentDiv = this.outerDiv;
+    if (suite.parentSuite) {
+      parentDiv = this.suiteDivs[suite.parentSuite.id];
+    }
+    parentDiv.appendChild(suiteDiv);
+  }
+
+  this.startedAt = new Date();
+
+  var self = this;
+  showPassed.onclick = function(evt) {
+    if (showPassed.checked) {
+      self.outerDiv.className += ' show-passed';
+    } else {
+      self.outerDiv.className = self.outerDiv.className.replace(/ show-passed/, '');
+    }
+  };
+
+  showSkipped.onclick = function(evt) {
+    if (showSkipped.checked) {
+      self.outerDiv.className += ' show-skipped';
+    } else {
+      self.outerDiv.className = self.outerDiv.className.replace(/ show-skipped/, '');
+    }
+  };
+};
+
+jasmine.TrivialReporter.prototype.reportRunnerResults = function(runner) {
+  var results = runner.results();
+  var className = (results.failedCount > 0) ? "runner failed" : "runner passed";
+  this.runnerDiv.setAttribute("class", className);
+  //do it twice for IE
+  this.runnerDiv.setAttribute("className", className);
+  var specs = runner.specs();
+  var specCount = 0;
+  for (var i = 0; i < specs.length; i++) {
+    if (this.specFilter(specs[i])) {
+      specCount++;
+    }
+  }
+  var message = "" + specCount + " spec" + (specCount == 1 ? "" : "s" ) + ", " + results.failedCount + " failure" + ((results.failedCount == 1) ? "" : "s");
+  message += " in " + ((new Date().getTime() - this.startedAt.getTime()) / 1000) + "s";
+  this.runnerMessageSpan.replaceChild(this.createDom('a', { className: 'description', href: '?'}, message), this.runnerMessageSpan.firstChild);
+
+  this.finishedAtSpan.appendChild(document.createTextNode("Finished at " + new Date().toString()));
+};
+
+jasmine.TrivialReporter.prototype.reportSuiteResults = function(suite) {
+  var results = suite.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.totalCount === 0) { // todo: change this to check results.skipped
+    status = 'skipped';
+  }
+  this.suiteDivs[suite.id].className += " " + status;
+};
+
+jasmine.TrivialReporter.prototype.reportSpecStarting = function(spec) {
+  if (this.logRunningSpecs) {
+    this.log('>> Jasmine Running ' + spec.suite.description + ' ' + spec.description + '...');
+  }
+};
+
+jasmine.TrivialReporter.prototype.reportSpecResults = function(spec) {
+  var results = spec.results();
+  var status = results.passed() ? 'passed' : 'failed';
+  if (results.skipped) {
+    status = 'skipped';
+  }
+  var specDiv = this.createDom('div', { className: 'spec '  + status },
+      this.createDom('a', { className: 'run_spec', href: '?spec=' + encodeURIComponent(spec.getFullName()) }, "run"),
+      this.createDom('a', {
+        className: 'description',
+        href: '?spec=' + encodeURIComponent(spec.getFullName()),
+        title: spec.getFullName()
+      }, spec.description));
+
+
+  var resultItems = results.getItems();
+  var messagesDiv = this.createDom('div', { className: 'messages' });
+  for (var i = 0; i < resultItems.length; i++) {
+    var result = resultItems[i];
+
+    if (result.type == 'log') {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage log'}, result.toString()));
+    } else if (result.type == 'expect' && result.passed && !result.passed()) {
+      messagesDiv.appendChild(this.createDom('div', {className: 'resultMessage fail'}, result.message));
+
+      if (result.trace.stack) {
+        messagesDiv.appendChild(this.createDom('div', {className: 'stackTrace'}, result.trace.stack));
+      }
+    }
+  }
+
+  if (messagesDiv.childNodes.length > 0) {
+    specDiv.appendChild(messagesDiv);
+  }
+
+  this.suiteDivs[spec.suite.id].appendChild(specDiv);
+};
+
+jasmine.TrivialReporter.prototype.log = function() {
+  var console = jasmine.getGlobal().console;
+  if (console && console.log) {
+    if (console.log.apply) {
+      console.log.apply(console, arguments);
+    } else {
+      console.log(arguments); // ie fix: console.log.apply doesn't exist on ie
+    }
+  }
+};
+
+jasmine.TrivialReporter.prototype.getLocation = function() {
+  return this.document.location;
+};
+
+jasmine.TrivialReporter.prototype.specFilter = function(spec) {
+  var paramMap = {};
+  var params = this.getLocation().search.substring(1).split('&');
+  for (var i = 0; i < params.length; i++) {
+    var p = params[i].split('=');
+    paramMap[decodeURIComponent(p[0])] = decodeURIComponent(p[1]);
+  }
+
+  if (!paramMap.spec) {
+    return true;
+  }
+  return spec.getFullName().indexOf(paramMap.spec) === 0;
+};

external/jasmine/jasmine.css

@@ -0,0 +1,81 @@
+body { background-color: #eeeeee; padding: 0; margin: 5px; overflow-y: scroll; }
+
+#HTMLReporter { font-size: 11px; font-family: Monaco, "Lucida Console", monospace; line-height: 14px; color: #333333; }
+#HTMLReporter a { text-decoration: none; }
+#HTMLReporter a:hover { text-decoration: underline; }
+#HTMLReporter p, #HTMLReporter h1, #HTMLReporter h2, #HTMLReporter h3, #HTMLReporter h4, #HTMLReporter h5, #HTMLReporter h6 { margin: 0; line-height: 14px; }
+#HTMLReporter .banner, #HTMLReporter .symbolSummary, #HTMLReporter .summary, #HTMLReporter .resultMessage, #HTMLReporter .specDetail .description, #HTMLReporter .alert .bar, #HTMLReporter .stackTrace { padding-left: 9px; padding-right: 9px; }
+#HTMLReporter #jasmine_content { position: fixed; right: 100%; }
+#HTMLReporter .version { color: #aaaaaa; }
+#HTMLReporter .banner { margin-top: 14px; }
+#HTMLReporter .duration { color: #aaaaaa; float: right; }
+#HTMLReporter .symbolSummary { overflow: hidden; *zoom: 1; margin: 14px 0; }
+#HTMLReporter .symbolSummary li { display: block; float: left; height: 7px; width: 14px; margin-bottom: 7px; font-size: 16px; }
+#HTMLReporter .symbolSummary li.passed { font-size: 14px; }
+#HTMLReporter .symbolSummary li.passed:before { color: #5e7d00; content: "\02022"; }
+#HTMLReporter .symbolSummary li.failed { line-height: 9px; }
+#HTMLReporter .symbolSummary li.failed:before { color: #b03911; content: "x"; font-weight: bold; margin-left: -1px; }
+#HTMLReporter .symbolSummary li.skipped { font-size: 14px; }
+#HTMLReporter .symbolSummary li.skipped:before { color: #bababa; content: "\02022"; }
+#HTMLReporter .symbolSummary li.pending { line-height: 11px; }
+#HTMLReporter .symbolSummary li.pending:before { color: #aaaaaa; content: "-"; }
+#HTMLReporter .bar { line-height: 28px; font-size: 14px; display: block; color: #eee; }
+#HTMLReporter .runningAlert { background-color: #666666; }
+#HTMLReporter .skippedAlert { background-color: #aaaaaa; }
+#HTMLReporter .skippedAlert:first-child { background-color: #333333; }
+#HTMLReporter .skippedAlert:hover { text-decoration: none; color: white; text-decoration: underline; }
+#HTMLReporter .passingAlert { background-color: #a6b779; }
+#HTMLReporter .passingAlert:first-child { background-color: #5e7d00; }
+#HTMLReporter .failingAlert { background-color: #cf867e; }
+#HTMLReporter .failingAlert:first-child { background-color: #b03911; }
+#HTMLReporter .results { margin-top: 14px; }
+#HTMLReporter #details { display: none; }
+#HTMLReporter .resultsMenu, #HTMLReporter .resultsMenu a { background-color: #fff; color: #333333; }
+#HTMLReporter.showDetails .summaryMenuItem { font-weight: normal; text-decoration: inherit; }
+#HTMLReporter.showDetails .summaryMenuItem:hover { text-decoration: underline; }
+#HTMLReporter.showDetails .detailsMenuItem { font-weight: bold; text-decoration: underline; }
+#HTMLReporter.showDetails .summary { display: none; }
+#HTMLReporter.showDetails #details { display: block; }
+#HTMLReporter .summaryMenuItem { font-weight: bold; text-decoration: underline; }
+#HTMLReporter .summary { margin-top: 14px; }
+#HTMLReporter .summary .suite .suite, #HTMLReporter .summary .specSummary { margin-left: 14px; }
+#HTMLReporter .summary .specSummary.passed a { color: #5e7d00; }
+#HTMLReporter .summary .specSummary.failed a { color: #b03911; }
+#HTMLReporter .description + .suite { margin-top: 0; }
+#HTMLReporter .suite { margin-top: 14px; }
+#HTMLReporter .suite a { color: #333333; }
+#HTMLReporter #details .specDetail { margin-bottom: 28px; }
+#HTMLReporter #details .specDetail .description { display: block; color: white; background-color: #b03911; }
+#HTMLReporter .resultMessage { padding-top: 14px; color: #333333; }
+#HTMLReporter .resultMessage span.result { display: block; }
+#HTMLReporter .stackTrace { margin: 5px 0 0 0; max-height: 224px; overflow: auto; line-height: 18px; color: #666666; border: 1px solid #ddd; background: white; white-space: pre; }
+
+#TrivialReporter { padding: 8px 13px; position: absolute; top: 0; bottom: 0; left: 0; right: 0; overflow-y: scroll; background-color: white; font-family: "Helvetica Neue Light", "Lucida Grande", "Calibri", "Arial", sans-serif; /*.resultMessage {*/ /*white-space: pre;*/ /*}*/ }
+#TrivialReporter a:visited, #TrivialReporter a { color: #303; }
+#TrivialReporter a:hover, #TrivialReporter a:active { color: blue; }
+#TrivialReporter .run_spec { float: right; padding-right: 5px; font-size: .8em; text-decoration: none; }
+#TrivialReporter .banner { color: #303; background-color: #fef; padding: 5px; }
+#TrivialReporter .logo { float: left; font-size: 1.1em; padding-left: 5px; }
+#TrivialReporter .logo .version { font-size: .6em; padding-left: 1em; }
+#TrivialReporter .runner.running { background-color: yellow; }
+#TrivialReporter .options { text-align: right; font-size: .8em; }
+#TrivialReporter .suite { border: 1px outset gray; margin: 5px 0; padding-left: 1em; }
+#TrivialReporter .suite .suite { margin: 5px; }
+#TrivialReporter .suite.passed { background-color: #dfd; }
+#TrivialReporter .suite.failed { background-color: #fdd; }
+#TrivialReporter .spec { margin: 5px; padding-left: 1em; clear: both; }
+#TrivialReporter .spec.failed, #TrivialReporter .spec.passed, #TrivialReporter .spec.skipped { padding-bottom: 5px; border: 1px solid gray; }
+#TrivialReporter .spec.failed { background-color: #fbb; border-color: red; }
+#TrivialReporter .spec.passed { background-color: #bfb; border-color: green; }
+#TrivialReporter .spec.skipped { background-color: #bbb; }
+#TrivialReporter .messages { border-left: 1px dashed gray; padding-left: 1em; padding-right: 1em; }
+#TrivialReporter .passed { background-color: #cfc; display: none; }
+#TrivialReporter .failed { background-color: #fbb; }
+#TrivialReporter .skipped { color: #777; background-color: #eee; display: none; }
+#TrivialReporter .resultMessage span.result { display: block; line-height: 2em; color: black; }
+#TrivialReporter .resultMessage .mismatch { color: black; }
+#TrivialReporter .stackTrace { white-space: pre; font-size: .8em; margin-left: 10px; max-height: 5em; overflow: auto; border: 1px inset red; padding: 1em; background: #eef; }
+#TrivialReporter .finished-at { padding-left: 1em; font-size: .6em; }
+#TrivialReporter.show-passed .passed, #TrivialReporter.show-skipped .skipped { display: block; }
+#TrivialReporter #jasmine_content { position: fixed; right: 100%; }
+#TrivialReporter .runner { border: 1px solid gray; display: block; margin: 5px 0; padding: 2px 0 2px 10px; }

src/canvas.js

@@ -445,7 +445,7 @@ var CanvasGraphics = (function canvasGraphics() {
           this.save();
           ctx.scale(fontSize, fontSize);
           ctx.transform.apply(ctx, fontMatrix);
-          this.executeIRQueue(glyph.IRQueue);
+          this.executeIRQueue(glyph.codeIRQueue);
           this.restore();
 
           var transformed = Util.applyTransform([glyph.width, 0], fontMatrix);
@@ -546,7 +546,9 @@ var CanvasGraphics = (function canvasGraphics() {
     setStrokeColor: function canvasGraphicsSetStrokeColor(/*...*/) {
       var cs = this.current.strokeColorSpace;
       var color = cs.getRgb(arguments);
-      this.setStrokeRGBColor.apply(this, color);
+      var color = Util.makeCssRgb.apply(null, cs.getRgb(arguments));
+      this.ctx.strokeStyle = color;
+      this.current.strokeColor = color;
     },
     getColorN_IR_Pattern: function canvasGraphicsGetColorN_IR_Pattern(IR, cs) {
       if (IR[0] == 'TilingPattern') {
@@ -581,8 +583,9 @@ var CanvasGraphics = (function canvasGraphics() {
     },
     setFillColor: function canvasGraphicsSetFillColor(/*...*/) {
       var cs = this.current.fillColorSpace;
-      var color = cs.getRgb(arguments);
-      this.setFillRGBColor.apply(this, color);
+      var color = Util.makeCssRgb.apply(null, cs.getRgb(arguments));
+      this.ctx.fillStyle = color;
+      this.current.fillColor = color;
     },
     setFillColorN_IR: function canvasGraphicsSetFillColorN(/*...*/) {
       var cs = this.current.fillColorSpace;
@@ -594,27 +597,49 @@ var CanvasGraphics = (function canvasGraphics() {
       }
     },
     setStrokeGray: function canvasGraphicsSetStrokeGray(gray) {
-      this.setStrokeRGBColor(gray, gray, gray);
+      if (!(this.current.strokeColorSpace instanceof DeviceGrayCS))
+        this.current.strokeColorSpace = new DeviceGrayCS();
+
+      var color = Util.makeCssRgb(gray, gray, gray);
+      this.ctx.strokeStyle = color;
+      this.current.strokeColor = color;
     },
     setFillGray: function canvasGraphicsSetFillGray(gray) {
-      this.setFillRGBColor(gray, gray, gray);
+      if (!(this.current.fillColorSpace instanceof DeviceGrayCS))
+        this.current.fillColorSpace = new DeviceGrayCS();
+
+      var color = Util.makeCssRgb(gray, gray, gray);
+      this.ctx.fillStyle = color;
+      this.current.fillColor = color;
     },
     setStrokeRGBColor: function canvasGraphicsSetStrokeRGBColor(r, g, b) {
+      if (!(this.current.strokeColorSpace instanceof DeviceRgbCS))
+        this.current.strokeColorSpace = new DeviceRgbCS();
+
       var color = Util.makeCssRgb(r, g, b);
       this.ctx.strokeStyle = color;
       this.current.strokeColor = color;
     },
     setFillRGBColor: function canvasGraphicsSetFillRGBColor(r, g, b) {
+      if (!(this.current.fillColorSpace instanceof DeviceRgbCS))
+        this.current.fillColorSpace = new DeviceRgbCS();
+
       var color = Util.makeCssRgb(r, g, b);
       this.ctx.fillStyle = color;
       this.current.fillColor = color;
     },
     setStrokeCMYKColor: function canvasGraphicsSetStrokeCMYKColor(c, m, y, k) {
+      if (!(this.current.strokeColorSpace instanceof DeviceCmykCS))
+        this.current.strokeColorSpace = new DeviceCmykCS();
+
       var color = Util.makeCssCmyk(c, m, y, k);
       this.ctx.strokeStyle = color;
       this.current.strokeColor = color;
     },
     setFillCMYKColor: function canvasGraphicsSetFillCMYKColor(c, m, y, k) {
+      if (!(this.current.fillColorSpace instanceof DeviceCmykCS))
+        this.current.fillColorSpace = new DeviceCmykCS();
+
       var color = Util.makeCssCmyk(c, m, y, k);
       this.ctx.fillStyle = color;
       this.current.fillColor = color;

src/colorspace.js

@@ -24,7 +24,7 @@ var ColorSpace = (function colorSpaceColorSpace() {
 
   constructor.parse = function colorSpaceParse(cs, xref, res) {
     var IR = constructor.parseToIR(cs, xref, res);
-    if (IR instanceof SeparationCS)
+    if (IR instanceof AlternateCS)
       return IR;
 
     return constructor.fromIR(IR);
@@ -50,11 +50,12 @@ var ColorSpace = (function colorSpaceColorSpace() {
         var hiVal = IR[2];
         var lookup = IR[3];
         return new IndexedCS(ColorSpace.fromIR(baseIndexedCS), hiVal, lookup);
-      case 'SeparationCS':
-        var alt = IR[1];
-        var tintFnIR = IR[2];
+      case 'AlternateCS':
+        var numComps = IR[1];
+        var alt = IR[2];
+        var tintFnIR = IR[3];
 
-        return new SeparationCS(ColorSpace.fromIR(alt),
+        return new AlternateCS(numComps, ColorSpace.fromIR(alt),
                                 PDFFunction.fromIR(tintFnIR));
       default:
         error('Unkown name ' + name);
@@ -134,11 +135,17 @@ var ColorSpace = (function colorSpaceColorSpace() {
           var lookup = xref.fetchIfRef(cs[3]);
           return ['IndexedCS', baseIndexedCS, hiVal, lookup];
         case 'Separation':
+        case 'DeviceN':
+          var name = cs[1];
+          var numComps = 1;
+          if (isName(name))
+            numComps = 1;
+          else if (isArray(name))
+            numComps = name.length;
           var alt = ColorSpace.parseToIR(cs[2], xref, res);
           var tintFnIR = PDFFunction.getIR(xref, xref.fetchIfRef(cs[3]));
-          return ['SeparationCS', alt, tintFnIR];
+          return ['AlternateCS', numComps, alt, tintFnIR];
         case 'Lab':
-        case 'DeviceN':
         default:
           error('unimplemented color space object "' + mode + '"');
       }
@@ -151,33 +158,45 @@ var ColorSpace = (function colorSpaceColorSpace() {
   return constructor;
 })();
 
-var SeparationCS = (function separationCS() {
-  function constructor(base, tintFn) {
-    this.name = 'Separation';
-    this.numComps = 1;
-    this.defaultColor = [1];
+/**
+ * Alternate color space handles both Separation and DeviceN color spaces.  A
+ * Separation color space is actually just a DeviceN with one color component.
+ * Both color spaces use a tinting function to convert colors to a base color
+ * space.
+ */
+var AlternateCS = (function alternateCS() {
+  function constructor(numComps, base, tintFn) {
+    this.name = 'Alternate';
+    this.numComps = numComps;
+    this.defaultColor = [];
+    for (var i = 0; i < numComps; ++i)
+      this.defaultColor.push(1);
     this.base = base;
     this.tintFn = tintFn;
   }
 
   constructor.prototype = {
-    getRgb: function sepcs_getRgb(color) {
+    getRgb: function altcs_getRgb(color) {
       var tinted = this.tintFn(color);
       return this.base.getRgb(tinted);
     },
-    getRgbBuffer: function sepcs_getRgbBuffer(input, bits) {
+    getRgbBuffer: function altcs_getRgbBuffer(input, bits) {
       var tintFn = this.tintFn;
       var base = this.base;
       var scale = 1 / ((1 << bits) - 1);
       var length = input.length;
       var pos = 0;
-      var numComps = base.numComps;
-      var baseBuf = new Uint8Array(numComps * length);
+      var baseNumComps = base.numComps;
+      var baseBuf = new Uint8Array(baseNumComps * length);
+      var numComps = this.numComps;
+      var scaled = new Array(numComps);
 
-      for (var i = 0; i < length; ++i) {
-        var scaled = input[i] * scale;
-        var tinted = tintFn([scaled]);
-        for (var j = 0; j < numComps; ++j)
+      for (var i = 0; i < length; i += numComps) {
+        for (var z = 0; z < numComps; ++z)
+          scaled[z] = input[i + z] * scale;
+
+        var tinted = tintFn(scaled);
+        for (var j = 0; j < baseNumComps; ++j)
           baseBuf[pos++] = 255 * tinted[j];
       }
       return base.getRgbBuffer(baseBuf, 8);

src/core.js

@@ -15,10 +15,6 @@ if (!globalScope.PDFJS) {
   globalScope.PDFJS = {};
 }
 
-// Temporarily disabling workers until 'localhost' FF bugfix lands:
-// https://bugzilla.mozilla.org/show_bug.cgi?id=683280
-globalScope.PDFJS.disableWorker = true;
-
 // getPdf()
 // Convenience function to perform binary Ajax GET
 // Usage: getPdf('http://...', callback)
@@ -471,6 +467,7 @@ var PDFDoc = (function pdfDoc() {
     this.objs = new PDFObjects();
 
     this.pageCache = [];
+    this.fontsLoading = {};
     this.workerReadyPromise = new Promise('workerReady');
 
     // If worker support isn't disabled explicit and the browser has worker
@@ -484,7 +481,16 @@ var PDFDoc = (function pdfDoc() {
         throw 'No PDFJS.workerSrc specified';
       }
 
-      var worker = new Worker(workerSrc);
+      var worker;
+      try {
+        worker = new Worker(workerSrc);
+      } catch (e) {
+        // Some versions of FF can't create a worker on localhost, see:
+        // https://bugzilla.mozilla.org/show_bug.cgi?id=683280
+        globalScope.PDFJS.disableWorker = true;
+        this.setupFakeWorker();
+        return;
+      }
 
       var messageHandler = new MessageHandler('main', worker);
 
@@ -505,8 +511,6 @@ var PDFDoc = (function pdfDoc() {
     } else {
       this.setupFakeWorker();
     }
-
-    this.fontsLoading = {};
   }
 
   constructor.prototype = {

src/evaluator.js

@@ -459,41 +459,18 @@ var PartialEvaluator = (function partialEvaluator() {
       };
     },
 
-    extractEncoding: function partialEvaluatorExtractEncoding(dict,
-                                                              xref,
-                                                              properties) {
-      var type = properties.type, encoding;
-      if (properties.composite) {
-        var defaultWidth = xref.fetchIfRef(dict.get('DW')) || 1000;
-        properties.defaultWidth = defaultWidth;
+    extractDataStructures: function
+      partialEvaluatorExtractDataStructures(dict, baseDict,
+                                            xref, properties) {
+      // 9.10.2
+      var toUnicode = dict.get('ToUnicode') ||
+        baseDict.get('ToUnicode');
+      if (toUnicode)
+        properties.toUnicode = this.readToUnicode(toUnicode, xref);
 
-        var glyphsWidths = {};
-        var widths = xref.fetchIfRef(dict.get('W'));
-        if (widths) {
-          var start = 0;
-          for (var i = 0, ii = widths.length; i < ii; i++) {
-            var code = widths[i];
-            if (isArray(code)) {
-              for (var j = 0, jj = code.length; j < jj; j++)
-                glyphsWidths[start++] = code[j];
-              start = 0;
-            } else if (start) {
-              var width = widths[++i];
-              for (var j = start; j <= code; j++)
-                glyphsWidths[j] = width;
-              start = 0;
-            } else {
-              start = code;
-            }
-          }
-        }
-        properties.widths = glyphsWidths;
-
-        // Glyph ids are big-endian 2-byte values
-        encoding = properties.encoding;
-
-        // CIDSystemInfo might help to match width and glyphs
-        var cidSystemInfo = dict.get('CIDSystemInfo');
+      if (properties.composite) {
+        // CIDSystemInfo helps to match CID to glyphs
+        var cidSystemInfo = xref.fetchIfRef(dict.get('CIDSystemInfo'));
         if (isDict(cidSystemInfo)) {
           properties.cidSystemInfo = {
             registry: cidSystemInfo.get('Registry'),
@@ -502,44 +479,20 @@ var PartialEvaluator = (function partialEvaluator() {
           };
         }
 
-        var cidToGidMap = dict.get('CIDToGIDMap');
-        if (!cidToGidMap || !isRef(cidToGidMap)) {
-
-
-          return Object.create(GlyphsUnicode);
-        }
-
-        // Extract the encoding from the CIDToGIDMap
-        var glyphsStream = xref.fetchIfRef(cidToGidMap);
-        var glyphsData = glyphsStream.getBytes(0);
-
-        // Set encoding 0 to later verify the font has an encoding
-        encoding[0] = { unicode: 0, width: 0 };
-        for (var j = 0, jj = glyphsData.length; j < jj; j++) {
-          var glyphID = (glyphsData[j++] << 8) | glyphsData[j];
-          if (glyphID == 0)
-            continue;
-
-          var code = j >> 1;
-          var width = glyphsWidths[code];
-          encoding[code] = {
-            unicode: glyphID,
-            width: isNum(width) ? width : defaultWidth
-          };
-        }
-
-        return Object.create(GlyphsUnicode);
+        var cidToGidMap = xref.fetchIfRef(dict.get('CIDToGIDMap'));
+        if (isStream(cidToGidMap))
+          properties.cidToGidMap = this.readCidToGidMap(cidToGidMap);
       }
 
-      var differences = properties.differences;
-      var map = properties.encoding;
-      var baseEncoding = null;
-      if (dict.has('Encoding')) {
-        encoding = xref.fetchIfRef(dict.get('Encoding'));
+      var differences = [];
+      var baseEncoding = Encodings.StandardEncoding;
+      var hasEncoding = dict.has('Encoding');
+      if (hasEncoding) {
+        var encoding = xref.fetchIfRef(dict.get('Encoding'));
         if (isDict(encoding)) {
           var baseName = encoding.get('BaseEncoding');
           if (baseName)
-            baseEncoding = Encodings[baseName.name].slice();
+            baseEncoding = Encodings[baseName.name];
 
           // Load the differences between the base and original
           if (encoding.has('Differences')) {
@@ -554,68 +507,23 @@ var PartialEvaluator = (function partialEvaluator() {
             }
           }
         } else if (isName(encoding)) {
-          baseEncoding = Encodings[encoding.name].slice();
+          baseEncoding = Encodings[encoding.name];
         } else {
           error('Encoding is not a Name nor a Dict');
         }
       }
+      properties.differences = differences;
+      properties.baseEncoding = baseEncoding;
+      properties.hasEncoding = hasEncoding;
+    },
 
-      if (!baseEncoding) {
-        switch (type) {
-          case 'TrueType':
-            baseEncoding = Encodings.WinAnsiEncoding.slice();
-            break;
-          case 'Type1':
-          case 'Type3':
-            baseEncoding = Encodings.StandardEncoding.slice();
-            break;
-          default:
-            warn('Unknown type of font: ' + type);
-            baseEncoding = [];
-            break;
-        }
-      }
-
-      // merge in the differences
-      var firstChar = properties.firstChar;
-      var lastChar = properties.lastChar;
-      var widths = properties.widths || [];
-      var glyphs = {};
-      for (var i = firstChar; i <= lastChar; i++) {
-        var glyph = differences[i];
-        var replaceGlyph = true;
-        if (!glyph) {
-          glyph = baseEncoding[i] || i;
-          replaceGlyph = false;
-        }
-        var index = GlyphsUnicode[glyph] || i;
-        var width = widths[i] || widths[glyph];
-        map[i] = {
-          unicode: index,
-          width: isNum(width) ? width : properties.defaultWidth
-        };
-
-        if (replaceGlyph || !glyphs[glyph])
-          glyphs[glyph] = map[i];
-        if (replaceGlyph || !glyphs[index])
-          glyphs[index] = map[i];
-
-        // If there is no file, the character mapping can't be modified
-        // but this is unlikely that there is any standard encoding with
-        // chars below 0x1f, so that's fine.
-        if (!properties.file)
-          continue;
-
-        if (index <= 0x1f || (index >= 127 && index <= 255))
-          map[i].unicode += kCmapGlyphOffset;
-      }
-
-      if (type == 'TrueType' && dict.has('ToUnicode') && differences) {
-        var cmapObj = dict.get('ToUnicode');
-        if (isRef(cmapObj)) {
-          cmapObj = xref.fetch(cmapObj);
-        }
+    readToUnicode:
+      function partialEvaluatorReadToUnicode(toUnicode, xref) {
+      var cmapObj = xref.fetchIfRef(toUnicode);
+      var charToUnicode = [];
       if (isName(cmapObj)) {
+        var isIdentityMap = cmapObj.name.substr(0, 9) == 'Identity-';
+        if (!isIdentityMap)
           error('ToUnicode file cmap translation not implemented');
       } else if (isStream(cmapObj)) {
         var tokens = [];
@@ -646,10 +554,8 @@ var PartialEvaluator = (function partialEvaluator() {
                   var startRange = tokens[j];
                   var endRange = tokens[j + 1];
                   var code = tokens[j + 2];
-                    while (startRange < endRange) {
-                      var mapping = map[startRange] || {};
-                      mapping.unicode = code++;
-                      map[startRange] = mapping;
+                  while (startRange <= endRange) {
+                    charToUnicode[startRange] = code++;
                     ++startRange;
                   }
                 }
@@ -660,9 +566,7 @@ var PartialEvaluator = (function partialEvaluator() {
                 for (var j = 0, jj = tokens.length; j < jj; j += 2) {
                   var index = tokens[j];
                   var code = tokens[j + 1];
-                    var mapping = map[index] || {};
-                    mapping.unicode = code;
-                    map[index] = mapping;
+                  charToUnicode[index] = code;
                 }
                 break;
 
@@ -700,34 +604,90 @@ var PartialEvaluator = (function partialEvaluator() {
           }
         }
       }
-      }
-      return glyphs;
+      return charToUnicode;
     },
+    readCidToGidMap:
+      function partialEvaluatorReadCidToGidMap(cidToGidStream) {
+      // Extract the encoding from the CIDToGIDMap
+      var glyphsData = cidToGidStream.getBytes();
 
-    getBaseFontMetricsAndMap: function getBaseFontMetricsAndMap(name) {
-      var map = {};
-      if (/^Symbol(-?(Bold|Italic))*$/.test(name)) {
-        // special case for symbols
-        var encoding = Encodings.symbolsEncoding.slice();
-        for (var i = 0, n = encoding.length, j; i < n; i++) {
-          j = encoding[i];
-          if (!j)
+      // Set encoding 0 to later verify the font has an encoding
+      var result = [];
+      for (var j = 0, jj = glyphsData.length; j < jj; j++) {
+        var glyphID = (glyphsData[j++] << 8) | glyphsData[j];
+        if (glyphID == 0)
           continue;
-          map[i] = GlyphsUnicode[j] || 0;
-        }
+
+        var code = j >> 1;
+        result[code] = glyphID;
       }
+      return result;
+    },
 
+    extractWidths: function partialEvaluatorWidths(dict,
+                                                   xref,
+                                                   descriptor,
+                                                   properties) {
+      var glyphsWidths = [];
       var defaultWidth = 0;
-      var widths = Metrics[stdFontMap[name] || name];
-      if (isNum(widths)) {
-        defaultWidth = widths;
-        widths = null;
+      if (properties.composite) {
+        defaultWidth = xref.fetchIfRef(dict.get('DW')) || 1000;
+
+        var widths = xref.fetchIfRef(dict.get('W'));
+        if (widths) {
+          var start = 0, end = 0;
+          for (var i = 0, ii = widths.length; i < ii; i++) {
+            var code = widths[i];
+            if (isArray(code)) {
+              for (var j = 0, jj = code.length; j < jj; j++)
+                glyphsWidths[start++] = code[j];
+              start = 0;
+            } else if (start) {
+              var width = widths[++i];
+              for (var j = start; j <= code; j++)
+                glyphsWidths[j] = width;
+              start = 0;
+            } else {
+              start = code;
+            }
+          }
+        }
+      } else {
+        var firstChar = properties.firstChar;
+        var widths = xref.fetchIfRef(dict.get('Widths'));
+        if (widths) {
+          var j = firstChar;
+          for (var i = 0, ii = widths.length; i < ii; i++)
+            glyphsWidths[j++] = widths[i];
+          defaultWidth = parseFloat(descriptor.get('MissingWidth')) || 0;
+        } else {
+          // Trying get the BaseFont metrics (see comment above).
+          var baseFontName = dict.get('BaseFont');
+          if (isName(baseFontName)) {
+            var metrics = this.getBaseFontMetrics(baseFontName.name);
+
+            glyphsWidths = metrics.widths;
+            defaultWidth = metrics.defaultWidth;
+          }
+        }
+      }
+
+      properties.defaultWidth = defaultWidth;
+      properties.widths = glyphsWidths;
+    },
+
+    getBaseFontMetrics: function getBaseFontMetrics(name) {
+      var defaultWidth = 0, widths = [];
+      var glyphWidths = Metrics[stdFontMap[name] || name];
+      if (isNum(glyphWidths)) {
+        defaultWidth = glyphWidths;
+      } else {
+        widths = glyphWidths;
       }
 
       return {
         defaultWidth: defaultWidth,
-        widths: widths || [],
-        map: map
+        widths: widths
       };
     },
 
@@ -756,6 +716,7 @@ var PartialEvaluator = (function partialEvaluator() {
         assertWellFormed(isName(type), 'invalid font Subtype');
         composite = true;
       }
+      var maxCharIndex = composite ? 0xFFFF : 0xFF;
 
       var descriptor = xref.fetchIfRef(dict.get('FontDescriptor'));
       if (!descriptor) {
@@ -774,18 +735,16 @@ var PartialEvaluator = (function partialEvaluator() {
 
           // Using base font name as a font name.
           baseFontName = baseFontName.name.replace(/[,_]/g, '-');
-          var metricsAndMap = this.getBaseFontMetricsAndMap(baseFontName);
+          var metrics = this.getBaseFontMetrics(baseFontName);
 
           var properties = {
             type: type.name,
-            encoding: metricsAndMap.map,
-            differences: [],
-            widths: metricsAndMap.widths,
-            defaultWidth: metricsAndMap.defaultWidth,
+            widths: metrics.widths,
+            defaultWidth: metrics.defaultWidth,
             firstChar: 0,
-            lastChar: 256
+            lastChar: maxCharIndex
           };
-          this.extractEncoding(dict, xref, properties);
+          this.extractDataStructures(dict, dict, xref, properties);
 
           return {
             name: baseFontName,
@@ -802,27 +761,7 @@ var PartialEvaluator = (function partialEvaluator() {
       // TODO Fill the width array depending on which of the base font this is
       // a variant.
       var firstChar = xref.fetchIfRef(dict.get('FirstChar')) || 0;
-      var lastChar = xref.fetchIfRef(dict.get('LastChar')) || 256;
-      var defaultWidth = 0;
-      var glyphWidths = {};
-      var encoding = {};
-      var widths = xref.fetchIfRef(dict.get('Widths'));
-      if (widths) {
-        for (var i = 0, j = firstChar, ii = widths.length; i < ii; i++, j++)
-          glyphWidths[j] = widths[i];
-        defaultWidth = parseFloat(descriptor.get('MissingWidth')) || 0;
-      } else {
-        // Trying get the BaseFont metrics (see comment above).
-        var baseFontName = dict.get('BaseFont');
-        if (isName(baseFontName)) {
-          var metricsAndMap = this.getBaseFontMetricsAndMap(baseFontName.name);
-
-          glyphWidths = metricsAndMap.widths;
-          defaultWidth = metricsAndMap.defaultWidth;
-          encoding = metricsAndMap.map;
-        }
-      }
-
+      var lastChar = xref.fetchIfRef(dict.get('LastChar')) || maxCharIndex;
       var fontName = xref.fetchIfRef(descriptor.get('FontName'));
       assertWellFormed(isName(fontName), 'invalid font name');
 
@@ -854,34 +793,30 @@ var PartialEvaluator = (function partialEvaluator() {
         fixedPitch: false,
         fontMatrix: dict.get('FontMatrix') || IDENTITY_MATRIX,
         firstChar: firstChar || 0,
-        lastChar: lastChar || 256,
+        lastChar: lastChar || maxCharIndex,
         bbox: descriptor.get('FontBBox'),
         ascent: descriptor.get('Ascent'),
         descent: descriptor.get('Descent'),
         xHeight: descriptor.get('XHeight'),
         capHeight: descriptor.get('CapHeight'),
-        defaultWidth: defaultWidth,
         flags: descriptor.get('Flags'),
         italicAngle: descriptor.get('ItalicAngle'),
-        differences: [],
-        widths: glyphWidths,
-        encoding: encoding,
         coded: false
       };
-      properties.glyphs = this.extractEncoding(dict, xref, properties);
+      this.extractWidths(dict, xref, descriptor, properties);
+      this.extractDataStructures(dict, baseDict, xref, properties);
 
       if (type.name === 'Type3') {
         properties.coded = true;
         var charProcs = xref.fetchIfRef(dict.get('CharProcs'));
         var fontResources = xref.fetchIfRef(dict.get('Resources')) || resources;
         properties.resources = fontResources;
+        properties.charProcIRQueues = {};
         for (var key in charProcs.map) {
           var glyphStream = xref.fetchIfRef(charProcs.map[key]);
           var queueObj = {};
-          properties.glyphs[key].IRQueue = this.getIRQueue(glyphStream,
-                                                           fontResources,
-                                                           queueObj,
-                                                           dependency);
+          properties.charProcIRQueues[key] =
+            this.getIRQueue(glyphStream, fontResources, queueObj, dependency);
         }
       }
 

src/function.js

@@ -20,6 +20,8 @@ var PDFFunction = (function pdfFunction() {
       var array = [];
       var codeSize = 0;
       var codeBuf = 0;
+      // 32 is a valid bps so shifting won't work
+      var sampleMul = 1.0 / (Math.pow(2.0, bps) - 1);
 
       var strBytes = str.getBytes((length * bps + 7) / 8);
       var strIdx = 0;
@@ -30,7 +32,7 @@ var PDFFunction = (function pdfFunction() {
           codeSize += 8;
         }
         codeSize -= bps;
-        array.push(codeBuf >> codeSize);
+        array.push((codeBuf >> codeSize) * sampleMul);
         codeBuf &= (1 << codeSize) - 1;
       }
       return array;
@@ -76,6 +78,17 @@ var PDFFunction = (function pdfFunction() {
     },
 
     constructSampled: function pdfFunctionConstructSampled(str, dict) {
+      function toMultiArray(arr) {
+        var inputLength = arr.length;
+        var outputLength = arr.length / 2;
+        var out = new Array(outputLength);
+        var index = 0;
+        for (var i = 0; i < inputLength; i += 2) {
+          out[index] = [arr[i], arr[i + 1]];
+          ++index;
+        }
+        return out;
+      }
       var domain = dict.get('Domain');
       var range = dict.get('Range');
 
@@ -85,9 +98,8 @@ var PDFFunction = (function pdfFunction() {
       var inputSize = domain.length / 2;
       var outputSize = range.length / 2;
 
-      if (inputSize != 1)
-        error('No support for multi-variable inputs to functions: ' +
-              inputSize);
+      domain = toMultiArray(domain);
+      range = toMultiArray(range);
 
       var size = dict.get('Size');
       var bps = dict.get('BitsPerSample');
@@ -105,15 +117,36 @@ var PDFFunction = (function pdfFunction() {
           encode.push(size[i] - 1);
         }
       }
+      encode = toMultiArray(encode);
+
       var decode = dict.get('Decode');
       if (!decode)
         decode = range;
+      else
+        decode = toMultiArray(decode);
+
+      // Precalc the multipliers
+      var inputMul = new Float64Array(inputSize);
+      for (var i = 0; i < inputSize; ++i) {
+        inputMul[i] = (encode[i][1] - encode[i][0]) /
+                  (domain[i][1] - domain[i][0]);
+      }
+
+      var idxMul = new Int32Array(inputSize);
+      idxMul[0] = outputSize;
+      for (i = 1; i < inputSize; ++i) {
+        idxMul[i] = idxMul[i - 1] * size[i - 1];
+      }
+
+      var nSamples = outputSize;
+      for (i = 0; i < inputSize; ++i)
+          nSamples *= size[i];
 
       var samples = this.getSampleArray(size, outputSize, bps, str);
 
       return [
         CONSTRUCT_SAMPLED, inputSize, domain, encode, decode, samples, size,
-        outputSize, bps, range
+        outputSize, bps, range, inputMul, idxMul, nSamples
       ];
     },
 
@@ -127,64 +160,74 @@ var PDFFunction = (function pdfFunction() {
       var outputSize = IR[7];
       var bps = IR[8];
       var range = IR[9];
+      var inputMul = IR[10];
+      var idxMul = IR[11];
+      var nSamples = IR[12];
 
       return function constructSampledFromIRResult(args) {
-        var clip = function constructSampledFromIRClip(v, min, max) {
-          if (v > max)
-            v = max;
-          else if (v < min)
-            v = min;
-          return v;
-        };
-
         if (inputSize != args.length)
           error('Incorrect number of arguments: ' + inputSize + ' != ' +
                 args.length);
-
-        for (var i = 0; i < inputSize; i++) {
-          var i2 = i * 2;
-
-          // clip to the domain
-          var v = clip(args[i], domain[i2], domain[i2 + 1]);
-
-          // encode
-          v = encode[i2] + ((v - domain[i2]) *
-                            (encode[i2 + 1] - encode[i2]) /
-                            (domain[i2 + 1] - domain[i2]));
-
-          // clip to the size
-          args[i] = clip(v, 0, size[i] - 1);
+        // Most of the below is a port of Poppler's implementation.
+        // TODO: There's a few other ways to do multilinear interpolation such
+        // as piecewise, which is much faster but an approximation.
+        var out = new Float64Array(outputSize);
+        var x;
+        var e = new Array(inputSize);
+        var efrac0 = new Float64Array(inputSize);
+        var efrac1 = new Float64Array(inputSize);
+        var sBuf = new Float64Array(1 << inputSize);
+        var i, j, k, idx, t;
+
+        // map input values into sample array
+        for (i = 0; i < inputSize; ++i) {
+          x = (args[i] - domain[i][0]) * inputMul[i] + encode[i][0];
+          if (x < 0) {
+            x = 0;
+          } else if (x > size[i] - 1) {
+            x = size[i] - 1;
+          }
+          e[i] = [Math.floor(x), 0];
+          if ((e[i][1] = e[i][0] + 1) >= size[i]) {
+            // this happens if in[i] = domain[i][1]
+            e[i][1] = e[i][0];
+          }
+          efrac1[i] = x - e[i][0];
+          efrac0[i] = 1 - efrac1[i];
         }
 
-        // interpolate to table
-        TODO('Multi-dimensional interpolation');
-        var floor = Math.floor(args[0]);
-        var ceil = Math.ceil(args[0]);
-        var scale = args[0] - floor;
-
-        floor *= outputSize;
-        ceil *= outputSize;
+        // for each output, do m-linear interpolation
+        for (i = 0; i < outputSize; ++i) {
 
-        var output = [], v = 0;
-        for (var i = 0; i < outputSize; ++i) {
-          if (ceil == floor) {
-            v = samples[ceil + i];
+          // pull 2^m values out of the sample array
+          for (j = 0; j < (1 << inputSize); ++j) {
+            idx = i;
+            for (k = 0, t = j; k < inputSize; ++k, t >>= 1) {
+              idx += idxMul[k] * (e[k][t & 1]);
+            }
+            if (idx >= 0 && idx < nSamples) {
+              sBuf[j] = samples[idx];
             } else {
-            var low = samples[floor + i];
-            var high = samples[ceil + i];
-            v = low * scale + high * (1 - scale);
+              sBuf[j] = 0; // TODO Investigate if this is what Adobe does
+            }
           }
 
-          var i2 = i * 2;
-          // decode
-          v = decode[i2] + (v * (decode[i2 + 1] - decode[i2]) /
-                            ((1 << bps) - 1));
-
-          // clip to the domain
-          output.push(clip(v, range[i2], range[i2 + 1]));
+          // do m sets of interpolations
+          for (j = 0, t = (1 << inputSize); j < inputSize; ++j, t >>= 1) {
+            for (k = 0; k < t; k += 2) {
+              sBuf[k >> 1] = efrac0[j] * sBuf[k] + efrac1[j] * sBuf[k + 1];
+            }
           }
 
-        return output;
+          // map output value to range
+          out[i] = (sBuf[0] * (decode[i][1] - decode[i][0]) + decode[i][0]);
+          if (out[i] < range[i][0]) {
+            out[i] = range[i][0];
+          } else if (out[i] > range[i][1]) {
+            out[i] = range[i][1];
+          }
+        }
+        return out;
       }
     },
 

src/pattern.js

@@ -19,10 +19,10 @@ var Pattern = (function patternPattern() {
 
   constructor.shadingFromIR = function pattern_shadingFromIR(ctx, raw) {
     return Shadings[raw[0]].fromIR(ctx, raw);
-  }
+  };
 
-  constructor.parseShading = function pattern_shading(shading, matrix,
-      xref, res, ctx) {
+  constructor.parseShading = function pattern_shading(shading, matrix, xref,
+                                                      res, ctx) {
 
     var dict = isStream(shading) ? shading.dict : shading;
     var type = dict.get('ShadingType');
@@ -116,17 +116,18 @@ Shadings.RadialAxial = (function radialAxialShading() {
       p1 = Util.applyTransform(p1, userMatrix);
     }
 
+    var grad;
     if (type == 2)
-      var grad = ctx.createLinearGradient(p0[0], p0[1], p1[0], p1[1]);
+      grad = ctx.createLinearGradient(p0[0], p0[1], p1[0], p1[1]);
     else if (type == 3)
-      var grad = ctx.createRadialGradient(p0[0], p0[1], r0, p1[0], p1[1], r1);
+      grad = ctx.createRadialGradient(p0[0], p0[1], r0, p1[0], p1[1], r1);
 
     for (var i = 0, ii = colorStops.length; i < ii; ++i) {
       var c = colorStops[i];
       grad.addColorStop(c[0], c[1]);
     }
     return grad;
-  }
+  };
 
   constructor.prototype = {
     getIR: function radialAxialShadingGetIR() {
@@ -166,7 +167,7 @@ Shadings.Dummy = (function dummyShading() {
 
   constructor.fromIR = function dummyShadingFromIR() {
     return 'hotpink';
-  }
+  };
 
   constructor.prototype = {
     getIR: function dummyShadingGetIR() {
@@ -242,9 +243,9 @@ var TilingPattern = (function tilingPattern() {
     graphics.transform.apply(graphics, tmpTranslate);
 
     if (bbox && isArray(bbox) && 4 == bbox.length) {
-      var bboxWidth = bbox[2] - bbox[0];
-      var bboxHeight = bbox[3] - bbox[1];
-      graphics.rectangle(bbox[0], bbox[1], bboxWidth, bboxHeight);
+      var bboxWidth = x1 - x0;
+      var bboxHeight = y1 - y0;
+      graphics.rectangle(x0, y0, bboxWidth, bboxHeight);
       graphics.clip();
       graphics.endPath();
     }
@@ -264,7 +265,7 @@ var TilingPattern = (function tilingPattern() {
     return [
       'TilingPattern', args, codeIR, matrix, bbox, xstep, ystep, paintType
     ];
-  }
+  };
 
   TilingPattern.prototype = {
     getPattern: function tiling_getPattern() {

src/pdf.js

@@ -7,8 +7,9 @@ var PDFJS = {};
   // Use strict in our context only - users might not want it
   'use strict';
 
+  PDFJS.build = 'PDFJSSCRIPT_BUNDLE_VER';
+
   // Files are inserted below - see Makefile
   /* PDFJSSCRIPT_INCLUDE_ALL */
 
 }).call((typeof window === 'undefined') ? this : window);
-

test/driver.js

@@ -7,6 +7,11 @@
 
 'use strict';
 
+// Disable worker support for running test as
+//   https://github.com/mozilla/pdf.js/pull/764#issuecomment-2638944
+//   "firefox-bin: Fatal IO error 12 (Cannot allocate memory) on X server :1."
+PDFJS.disableWorker = true;
+
 var appPath, browser, canvas, currentTaskIdx, manifest, stdout;
 var inFlightRequests = 0;
 
@@ -51,23 +56,29 @@ function load() {
 }
 
 function cleanup() {
+  // Clear out all the stylesheets since a new one is created for each font.
+  while (document.styleSheets.length > 0) {
     var styleSheet = document.styleSheets[0];
-  if (styleSheet) {
     while (styleSheet.cssRules.length > 0)
       styleSheet.deleteRule(0);
+    var ownerNode = styleSheet.ownerNode;
+    ownerNode.parentNode.removeChild(ownerNode);
   }
   var guard = document.getElementById('content-end');
   var body = document.body;
   while (body.lastChild !== guard)
     body.removeChild(body.lastChild);
+
+  // Wipe out the link to the pdfdoc so it can be GC'ed.
+  for (var i = 0; i < manifest.length; i++) {
+    if (manifest[i].pdfDoc) {
+      manifest[i].pdfDoc.destroy();
+      delete manifest[i].pdfDoc;
+    }
+  }
 }
 
 function nextTask() {
-  // If there is a pdfDoc on the last task executed, destroy it to free memory.
-  if (task && task.pdfDoc) {
-    task.pdfDoc.destroy();
-    delete task.pdfDoc;
-  }
   cleanup();
 
   if (currentTaskIdx == manifest.length) {

test/pdfs/.gitignore

@@ -14,4 +14,5 @@
 !sizes.pdf
 !close-path-bug.pdf
 !alphatrans.pdf
+!devicen.pdf
 !cmykjpeg.pdf

test/test.py

@@ -323,18 +323,18 @@ def verifyPDFs(manifestList):
         if os.access(f, os.R_OK):
             fileMd5 = hashlib.md5(open(f, 'rb').read()).hexdigest()
             if 'md5' not in item:
-                print 'ERROR: Missing md5 for file "' + f + '".',
+                print 'WARNING: Missing md5 for file "' + f + '".',
                 print 'Hash for current file is "' + fileMd5 + '"'
                 error = True
                 continue
             md5 = item['md5']
             if fileMd5 != md5:
-                print 'ERROR: MD5 of file "' + f + '" does not match file.',
+                print 'WARNING: MD5 of file "' + f + '" does not match file.',
                 print 'Expected "' + md5 + '" computed "' + fileMd5 + '"'
                 error = True
                 continue
         else:
-            print 'ERROR: Unable to open file for reading "' + f + '".'
+            print 'WARNING: Unable to open file for reading "' + f + '".'
             error = True
     return not error
 
@@ -365,7 +365,8 @@ def setUp(options):
     downloadLinkedPDFs(manifestList)
 
     if not verifyPDFs(manifestList):
-        raise Exception('ERROR: failed to verify pdfs.')
+      print 'Unable to verify the checksum for the files that are used for testing.'
+      print 'Please re-download the files, or adjust the MD5 checksum in the manifest for the files listed above.\n'
 
     for b in testBrowsers:
         State.taskResults[b.name] = { }

test/test_manifest.json

@@ -19,6 +19,7 @@
     },
     {  "id": "intelisa-load",
        "file": "pdfs/intelisa.pdf",
+       "md5": "f5712097d29287a97f1278839814f682",
        "md5": "f3ed5487d1afa34d8b77c0c734a95c79",
        "link": true,
        "rounds": 1,
@@ -187,7 +188,7 @@
     },
     {  "id": "f1040",
        "file": "pdfs/f1040.pdf",
-       "md5": "7323b50c6d28d959b8b4b92c469b2469",
+       "md5": "b59272ce19b4a0c5808c8861441b0741",
        "link": true,
        "rounds": 1,
        "type": "load"
@@ -262,9 +263,16 @@
        "rounds": 1,
        "type": "eq"
     },
+    {  "id": "devicen",
+       "file": "pdfs/devicen.pdf",
+       "md5": "aac6a91725435d1376c6ff492dc5cb75",
+       "link": false,
+       "rounds": 1,
+       "type": "eq"
+    },
     {  "id": "cmykjpeg",
        "file": "pdfs/cmykjpeg.pdf",
-       "md5": "8307472972ba962d86d2f60d2ced9a97",
+       "md5": "85d162b48ce98503a382d96f574f70a2",
        "link": false,
        "rounds": 1,
        "type": "eq"

test/unit/obj_spec.js

@@ -0,0 +1,16 @@
+/* -*- Mode: Java; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set shiftwidth=2 tabstop=2 autoindent cindent expandtab: */
+
+'use strict';
+
+describe("obj", function() {
+
+  describe("Name", function() {
+    it("should retain the given name", function() {
+      var givenName = "Font";
+      var name = new Name(givenName);
+      expect(name.name).toEqual(givenName);
+    });
+  });
+});
+

test/unit/unit_test.html

@@ -0,0 +1,51 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>pdf.js unit test</title>
+
+  <link rel="shortcut icon" type="image/png" href="../../external/jasmine/jasmine_favicon.png">
+  <link rel="stylesheet" type="text/css" href="../../external/jasmine/jasmine.css">
+
+  <script type="text/javascript" src="../../external/jasmine/jasmine.js"></script>
+  <script type="text/javascript" src="../../external/jasmine/jasmine-html.js"></script>
+
+  <!-- include spec files here... -->
+  <script type="text/javascript" src="obj_spec.js"></script>
+
+  <!-- include source files here... -->
+  <script type="text/javascript" src="../../src/obj.js"></script>
+
+  <script type="text/javascript">
+    'use strict';
+
+    (function pdfJsUnitTest() {
+      var jasmineEnv = jasmine.getEnv();
+      jasmineEnv.updateInterval = 1000;
+
+      var trivialReporter = new jasmine.TrivialReporter();
+
+      jasmineEnv.addReporter(trivialReporter);
+
+      jasmineEnv.specFilter = function pdfJsUnitTestSpecFilter(spec) {
+        return trivialReporter.specFilter(spec);
+      };
+
+      var currentWindowOnload = window.onload;
+
+      window.onload = function pdfJsUnitTestOnload() {
+        if (currentWindowOnload) {
+          currentWindowOnload();
+        }
+        execJasmine();
+      };
+
+      function execJasmine() {
+        jasmineEnv.execute();
+      }
+    })();
+  </script>
+</head>
+<body>
+</body>
+</html>
+