pdfjs-dist 2.0.487 → 2.1.266

package/lib/core/parser.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2017 Mozilla Foundation
+ * Copyright 2018 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,42 +19,43 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.Parser = exports.Linearization = exports.Lexer = undefined;
+exports.Parser = exports.Linearization = exports.Lexer = void 0;
 
-var _stream = require('./stream');
+var _stream = require("./stream");
 
-var _util = require('../shared/util');
+var _util = require("../shared/util");
 
-var _primitives = require('./primitives');
+var _primitives = require("./primitives");
 
-var _ccitt_stream = require('./ccitt_stream');
+var _ccitt_stream = require("./ccitt_stream");
 
-var _jbig2_stream = require('./jbig2_stream');
+var _jbig2_stream = require("./jbig2_stream");
 
-var _jpeg_stream = require('./jpeg_stream');
+var _jpeg_stream = require("./jpeg_stream");
 
-var _jpx_stream = require('./jpx_stream');
+var _jpx_stream = require("./jpx_stream");
 
 var MAX_LENGTH_TO_CACHE = 1000;
 var MAX_ADLER32_LENGTH = 5552;
+
 function computeAdler32(bytes) {
   var bytesLength = bytes.length;
-  if (bytesLength >= MAX_ADLER32_LENGTH) {
-    throw new Error('computeAdler32: The input is too large.');
-  }
   var a = 1,
       b = 0;
+
   for (var i = 0; i < bytesLength; ++i) {
     a += bytes[i] & 0xFF;
     b += a;
   }
+
   return b % 65521 << 16 | a % 65521;
 }
+
 var Parser = function ParserClosure() {
   function Parser(lexer, allowStreams, xref, recoveryMode) {
     this.lexer = lexer;
@@ -64,6 +65,7 @@ var Parser = function ParserClosure() {
     this.imageCache = Object.create(null);
     this.refill();
   }
+
   Parser.prototype = {
     refill: function Parser_refill() {
       this.buf1 = this.lexer.getObj();
@@ -86,76 +88,100 @@ var Parser = function ParserClosure() {
         if (e instanceof _util.MissingDataException) {
           throw e;
         }
+
         return false;
       }
     },
     getObj: function Parser_getObj(cipherTransform) {
       var buf1 = this.buf1;
       this.shift();
+
       if (buf1 instanceof _primitives.Cmd) {
         switch (buf1.cmd) {
           case 'BI':
             return this.makeInlineImage(cipherTransform);
+
           case '[':
             var array = [];
+
             while (!(0, _primitives.isCmd)(this.buf1, ']') && !(0, _primitives.isEOF)(this.buf1)) {
               array.push(this.getObj(cipherTransform));
             }
+
             if ((0, _primitives.isEOF)(this.buf1)) {
               if (!this.recoveryMode) {
                 throw new _util.FormatError('End of file inside array');
               }
+
               return array;
             }
+
             this.shift();
             return array;
+
           case '<<':
             var dict = new _primitives.Dict(this.xref);
+
             while (!(0, _primitives.isCmd)(this.buf1, '>>') && !(0, _primitives.isEOF)(this.buf1)) {
               if (!(0, _primitives.isName)(this.buf1)) {
                 (0, _util.info)('Malformed dictionary: key must be a name object');
                 this.shift();
                 continue;
               }
+
               var key = this.buf1.name;
               this.shift();
+
               if ((0, _primitives.isEOF)(this.buf1)) {
                 break;
               }
+
               dict.set(key, this.getObj(cipherTransform));
             }
+
             if ((0, _primitives.isEOF)(this.buf1)) {
               if (!this.recoveryMode) {
                 throw new _util.FormatError('End of file inside dictionary');
               }
+
               return dict;
             }
+
             if ((0, _primitives.isCmd)(this.buf2, 'stream')) {
               return this.allowStreams ? this.makeStream(dict, cipherTransform) : dict;
             }
+
             this.shift();
             return dict;
+
           default:
             return buf1;
         }
       }
+
       if (Number.isInteger(buf1)) {
         var num = buf1;
+
         if (Number.isInteger(this.buf1) && (0, _primitives.isCmd)(this.buf2, 'R')) {
           var ref = new _primitives.Ref(num, this.buf1);
           this.shift();
           this.shift();
           return ref;
         }
+
         return num;
       }
+
       if ((0, _util.isString)(buf1)) {
         var str = buf1;
+
         if (cipherTransform) {
           str = cipherTransform.decryptString(str);
         }
+
         return str;
       }
+
       return buf1;
     },
     findDefaultInlineStreamEnd: function findDefaultInlineStreamEnd(stream) {
@@ -168,8 +194,9 @@ var Parser = function ParserClosure() {
           NUL = 0x0;
       var startPos = stream.pos,
           state = 0,
-          ch = void 0,
-          maybeEIPos = void 0;
+          ch,
+          maybeEIPos;
+
       while ((ch = stream.getByte()) !== -1) {
         if (state === 0) {
           state = ch === E ? 1 : 0;
@@ -177,19 +204,24 @@ var Parser = function ParserClosure() {
           state = ch === I ? 2 : 0;
         } else {
           (0, _util.assert)(state === 2);
+
           if (ch === SPACE || ch === LF || ch === CR) {
             maybeEIPos = stream.pos;
             var followingBytes = stream.peekBytes(n);
+
             for (var i = 0, ii = followingBytes.length; i < ii; i++) {
               ch = followingBytes[i];
+
               if (ch === NUL && followingBytes[i + 1] !== NUL) {
                 continue;
               }
+
               if (ch !== LF && ch !== CR && (ch < SPACE || ch > 0x7F)) {
                 state = 0;
                 break;
               }
             }
+
             if (state === 2) {
               break;
             }
@@ -198,35 +230,51 @@ var Parser = function ParserClosure() {
           }
         }
       }
+
       if (ch === -1) {
         (0, _util.warn)('findDefaultInlineStreamEnd: ' + 'Reached the end of the stream without finding a valid EI marker');
+
         if (maybeEIPos) {
           (0, _util.warn)('... trying to recover by using the last "EI" occurrence.');
           stream.skip(-(stream.pos - maybeEIPos));
         }
       }
-      return stream.pos - 4 - startPos;
-    },
 
+      var endOffset = 4;
+      stream.skip(-endOffset);
+      ch = stream.peekByte();
+      stream.skip(endOffset);
+
+      if (!(0, _util.isSpace)(ch)) {
+        endOffset--;
+      }
+
+      return stream.pos - endOffset - startPos;
+    },
     findDCTDecodeInlineStreamEnd: function Parser_findDCTDecodeInlineStreamEnd(stream) {
       var startPos = stream.pos,
           foundEOI = false,
           b,
           markerLength,
           length;
+
       while ((b = stream.getByte()) !== -1) {
         if (b !== 0xFF) {
           continue;
         }
+
         switch (stream.getByte()) {
           case 0x00:
             break;
+
           case 0xFF:
             stream.skip(-1);
             break;
+
           case 0xD9:
             foundEOI = true;
             break;
+
           case 0xC0:
           case 0xC1:
           case 0xC2:
@@ -266,23 +314,29 @@ var Parser = function ParserClosure() {
           case 0xEF:
           case 0xFE:
             markerLength = stream.getUint16();
+
             if (markerLength > 2) {
               stream.skip(markerLength - 2);
             } else {
               stream.skip(-2);
             }
+
             break;
         }
+
         if (foundEOI) {
           break;
         }
       }
+
       length = stream.pos - startPos;
+
       if (b === -1) {
         (0, _util.warn)('Inline DCTDecode image stream: ' + 'EOI marker not found, searching for /EI/ instead.');
         stream.skip(-length);
         return this.findDefaultInlineStreamEnd(stream);
       }
+
       this.inlineStreamSkipEI(stream);
       return length;
     },
@@ -292,18 +346,22 @@ var Parser = function ParserClosure() {
       var startPos = stream.pos,
           ch,
           length;
+
       while ((ch = stream.getByte()) !== -1) {
         if (ch === TILDE && stream.peekByte() === GT) {
           stream.skip();
           break;
         }
       }
+
       length = stream.pos - startPos;
+
       if (ch === -1) {
         (0, _util.warn)('Inline ASCII85Decode image stream: ' + 'EOD marker not found, searching for /EI/ instead.');
         stream.skip(-length);
         return this.findDefaultInlineStreamEnd(stream);
       }
+
       this.inlineStreamSkipEI(stream);
       return length;
     },
@@ -312,17 +370,21 @@ var Parser = function ParserClosure() {
       var startPos = stream.pos,
           ch,
           length;
+
       while ((ch = stream.getByte()) !== -1) {
         if (ch === GT) {
           break;
         }
       }
+
       length = stream.pos - startPos;
+
       if (ch === -1) {
         (0, _util.warn)('Inline ASCIIHexDecode image stream: ' + 'EOD marker not found, searching for /EI/ instead.');
         stream.skip(-length);
         return this.findDefaultInlineStreamEnd(stream);
       }
+
       this.inlineStreamSkipEI(stream);
       return length;
     },
@@ -331,6 +393,7 @@ var Parser = function ParserClosure() {
           I = 0x49;
       var state = 0,
           ch;
+
       while ((ch = stream.getByte()) !== -1) {
         if (state === 0) {
           state = ch === E ? 1 : 0;
@@ -345,33 +408,43 @@ var Parser = function ParserClosure() {
       var lexer = this.lexer;
       var stream = lexer.stream;
       var dict = new _primitives.Dict(this.xref),
-          dictLength = void 0;
+          dictLength;
+
       while (!(0, _primitives.isCmd)(this.buf1, 'ID') && !(0, _primitives.isEOF)(this.buf1)) {
         if (!(0, _primitives.isName)(this.buf1)) {
           throw new _util.FormatError('Dictionary key must be a name object');
         }
+
         var key = this.buf1.name;
         this.shift();
+
         if ((0, _primitives.isEOF)(this.buf1)) {
           break;
         }
+
         dict.set(key, this.getObj(cipherTransform));
       }
+
       if (lexer.beginInlineImagePos !== -1) {
         dictLength = stream.pos - lexer.beginInlineImagePos;
       }
+
       var filter = dict.get('Filter', 'F'),
           filterName;
+
       if ((0, _primitives.isName)(filter)) {
         filterName = filter.name;
       } else if (Array.isArray(filter)) {
         var filterZero = this.xref.fetchIfRef(filter[0]);
+
         if ((0, _primitives.isName)(filterZero)) {
           filterName = filterZero.name;
         }
       }
+
       var startPos = stream.pos,
-          length = void 0;
+          length;
+
       if (filterName === 'DCTDecode' || filterName === 'DCT') {
         length = this.findDCTDecodeInlineStreamEnd(stream);
       } else if (filterName === 'ASCII85Decode' || filterName === 'A85') {
@@ -381,8 +454,10 @@ var Parser = function ParserClosure() {
       } else {
         length = this.findDefaultInlineStreamEnd(stream);
       }
+
       var imageStream = stream.makeSubStream(startPos, length, dict);
-      var cacheKey = void 0;
+      var cacheKey;
+
       if (length < MAX_LENGTH_TO_CACHE && dictLength < MAX_ADLER32_LENGTH) {
         var imageBytes = imageStream.getBytes();
         imageStream.reset();
@@ -392,6 +467,7 @@ var Parser = function ParserClosure() {
         stream.pos = initialStreamPos;
         cacheKey = computeAdler32(imageBytes) + '_' + computeAdler32(dictBytes);
         var cacheEntry = this.imageCache[cacheKey];
+
         if (cacheEntry !== undefined) {
           this.buf2 = _primitives.Cmd.get('EI');
           this.shift();
@@ -399,82 +475,121 @@ var Parser = function ParserClosure() {
           return cacheEntry;
         }
       }
+
       if (cipherTransform) {
         imageStream = cipherTransform.createStream(imageStream, length);
       }
+
       imageStream = this.filter(imageStream, dict, length);
       imageStream.dict = dict;
+
       if (cacheKey !== undefined) {
         imageStream.cacheKey = 'inline_' + length + '_' + cacheKey;
         this.imageCache[cacheKey] = imageStream;
       }
+
       this.buf2 = _primitives.Cmd.get('EI');
       this.shift();
       return imageStream;
     },
+    _findStreamLength: function _findStreamLength(startPos, signature) {
+      var stream = this.lexer.stream;
+      stream.pos = startPos;
+      var SCAN_BLOCK_LENGTH = 2048;
+      var signatureLength = signature.length;
+
+      while (stream.pos < stream.end) {
+        var scanBytes = stream.peekBytes(SCAN_BLOCK_LENGTH);
+        var scanLength = scanBytes.length - signatureLength;
+
+        if (scanLength <= 0) {
+          break;
+        }
+
+        var pos = 0;
+
+        while (pos < scanLength) {
+          var j = 0;
+
+          while (j < signatureLength && scanBytes[pos + j] === signature[j]) {
+            j++;
+          }
+
+          if (j >= signatureLength) {
+            stream.pos += pos;
+            return stream.pos - startPos;
+          }
+
+          pos++;
+        }
+
+        stream.pos += scanLength;
+      }
+
+      return -1;
+    },
     makeStream: function Parser_makeStream(dict, cipherTransform) {
       var lexer = this.lexer;
       var stream = lexer.stream;
       lexer.skipToNextLine();
-      var pos = stream.pos - 1;
+      var startPos = stream.pos - 1;
       var length = dict.get('Length');
+
       if (!Number.isInteger(length)) {
         (0, _util.info)('Bad ' + length + ' attribute in stream');
         length = 0;
       }
-      stream.pos = pos + length;
+
+      stream.pos = startPos + length;
       lexer.nextChar();
+
       if (this.tryShift() && (0, _primitives.isCmd)(this.buf2, 'endstream')) {
         this.shift();
       } else {
-        stream.pos = pos;
-        var SCAN_BLOCK_SIZE = 2048;
-        var ENDSTREAM_SIGNATURE_LENGTH = 9;
-        var ENDSTREAM_SIGNATURE = [0x65, 0x6E, 0x64, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D];
-        var skipped = 0,
-            found = false,
-            i,
-            j;
-        while (stream.pos < stream.end) {
-          var scanBytes = stream.peekBytes(SCAN_BLOCK_SIZE);
-          var scanLength = scanBytes.length - ENDSTREAM_SIGNATURE_LENGTH;
-          if (scanLength <= 0) {
-            break;
-          }
-          found = false;
-          i = 0;
-          while (i < scanLength) {
-            j = 0;
-            while (j < ENDSTREAM_SIGNATURE_LENGTH && scanBytes[i + j] === ENDSTREAM_SIGNATURE[j]) {
-              j++;
-            }
-            if (j >= ENDSTREAM_SIGNATURE_LENGTH) {
-              found = true;
+        var ENDSTREAM_SIGNATURE = new Uint8Array([0x65, 0x6E, 0x64, 0x73, 0x74, 0x72, 0x65, 0x61, 0x6D]);
+
+        var actualLength = this._findStreamLength(startPos, ENDSTREAM_SIGNATURE);
+
+        if (actualLength < 0) {
+          var MAX_TRUNCATION = 1;
+
+          for (var i = 1; i <= MAX_TRUNCATION; i++) {
+            var end = ENDSTREAM_SIGNATURE.length - i;
+            var TRUNCATED_SIGNATURE = ENDSTREAM_SIGNATURE.slice(0, end);
+
+            var maybeLength = this._findStreamLength(startPos, TRUNCATED_SIGNATURE);
+
+            if (maybeLength >= 0) {
+              var lastByte = stream.peekBytes(end + 1)[end];
+
+              if (!(0, _util.isSpace)(lastByte)) {
+                break;
+              }
+
+              (0, _util.info)("Found \"".concat((0, _util.bytesToString)(TRUNCATED_SIGNATURE), "\" when ") + 'searching for endstream command.');
+              actualLength = maybeLength;
               break;
             }
-            i++;
           }
-          if (found) {
-            skipped += i;
-            stream.pos += i;
-            break;
+
+          if (actualLength < 0) {
+            throw new _util.FormatError('Missing endstream command.');
           }
-          skipped += scanLength;
-          stream.pos += scanLength;
-        }
-        if (!found) {
-          throw new _util.FormatError('Missing endstream');
         }
-        length = skipped;
+
+        length = actualLength;
         lexer.nextChar();
         this.shift();
         this.shift();
       }
+
       this.shift();
-      stream = stream.makeSubStream(pos, length, dict);
+      stream = stream.makeSubStream(startPos, length, dict);
+
       if (cipherTransform) {
         stream = cipherTransform.createStream(stream, length);
       }
+
       stream = this.filter(stream, dict, length);
       stream.dict = dict;
       return stream;
@@ -482,29 +597,39 @@ var Parser = function ParserClosure() {
     filter: function Parser_filter(stream, dict, length) {
       var filter = dict.get('Filter', 'F');
       var params = dict.get('DecodeParms', 'DP');
+
       if ((0, _primitives.isName)(filter)) {
         if (Array.isArray(params)) {
           (0, _util.warn)('/DecodeParms should not contain an Array, ' + 'when /Filter contains a Name.');
         }
+
         return this.makeFilter(stream, filter.name, length, params);
       }
+
       var maybeLength = length;
+
       if (Array.isArray(filter)) {
         var filterArray = filter;
         var paramsArray = params;
+
         for (var i = 0, ii = filterArray.length; i < ii; ++i) {
           filter = this.xref.fetchIfRef(filterArray[i]);
+
           if (!(0, _primitives.isName)(filter)) {
             throw new _util.FormatError('Bad filter name: ' + filter);
           }
+
           params = null;
+
           if (Array.isArray(paramsArray) && i in paramsArray) {
             params = this.xref.fetchIfRef(paramsArray[i]);
           }
+
           stream = this.makeFilter(stream, filter.name, maybeLength, params);
           maybeLength = null;
         }
       }
+
       return stream;
     },
     makeFilter: function Parser_makeFilter(stream, name, maybeLength, params) {
@@ -512,60 +637,77 @@ var Parser = function ParserClosure() {
         (0, _util.warn)('Empty "' + name + '" stream.');
         return new _stream.NullStream();
       }
+
       try {
         var xrefStreamStats = this.xref.stats.streamTypes;
+
         if (name === 'FlateDecode' || name === 'Fl') {
           xrefStreamStats[_util.StreamType.FLATE] = true;
+
           if (params) {
             return new _stream.PredictorStream(new _stream.FlateStream(stream, maybeLength), maybeLength, params);
           }
+
           return new _stream.FlateStream(stream, maybeLength);
         }
+
         if (name === 'LZWDecode' || name === 'LZW') {
           xrefStreamStats[_util.StreamType.LZW] = true;
           var earlyChange = 1;
+
           if (params) {
             if (params.has('EarlyChange')) {
               earlyChange = params.get('EarlyChange');
             }
+
             return new _stream.PredictorStream(new _stream.LZWStream(stream, maybeLength, earlyChange), maybeLength, params);
           }
+
           return new _stream.LZWStream(stream, maybeLength, earlyChange);
         }
+
         if (name === 'DCTDecode' || name === 'DCT') {
           xrefStreamStats[_util.StreamType.DCT] = true;
           return new _jpeg_stream.JpegStream(stream, maybeLength, stream.dict, params);
         }
+
         if (name === 'JPXDecode' || name === 'JPX') {
           xrefStreamStats[_util.StreamType.JPX] = true;
           return new _jpx_stream.JpxStream(stream, maybeLength, stream.dict, params);
         }
+
         if (name === 'ASCII85Decode' || name === 'A85') {
           xrefStreamStats[_util.StreamType.A85] = true;
           return new _stream.Ascii85Stream(stream, maybeLength);
         }
+
         if (name === 'ASCIIHexDecode' || name === 'AHx') {
           xrefStreamStats[_util.StreamType.AHX] = true;
           return new _stream.AsciiHexStream(stream, maybeLength);
         }
+
         if (name === 'CCITTFaxDecode' || name === 'CCF') {
           xrefStreamStats[_util.StreamType.CCF] = true;
           return new _ccitt_stream.CCITTFaxStream(stream, maybeLength, params);
         }
+
         if (name === 'RunLengthDecode' || name === 'RL') {
           xrefStreamStats[_util.StreamType.RL] = true;
           return new _stream.RunLengthStream(stream, maybeLength);
         }
+
         if (name === 'JBIG2Decode') {
           xrefStreamStats[_util.StreamType.JBIG] = true;
           return new _jbig2_stream.Jbig2Stream(stream, maybeLength, stream.dict, params);
         }
+
         (0, _util.warn)('filter "' + name + '" not supported yet');
         return stream;
       } catch (ex) {
         if (ex instanceof _util.MissingDataException) {
           throw ex;
         }
+
         (0, _util.warn)('Invalid stream: \"' + ex + '\"');
         return new _stream.NullStream();
       }
@@ -573,6 +715,9 @@ var Parser = function ParserClosure() {
   };
   return Parser;
 }();
+
+exports.Parser = Parser;
+
 var Lexer = function LexerClosure() {
   function Lexer(stream, knownCommands) {
     this.stream = stream;
@@ -581,16 +726,21 @@ var Lexer = function LexerClosure() {
     this.knownCommands = knownCommands;
     this.beginInlineImagePos = -1;
   }
+
   var specialChars = [1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 2, 0, 0, 2, 2, 0, 0, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+
   function toHexDigit(ch) {
     if (ch >= 0x30 && ch <= 0x39) {
       return ch & 0x0F;
     }
+
     if (ch >= 0x41 && ch <= 0x46 || ch >= 0x61 && ch <= 0x66) {
       return (ch & 0x0F) + 9;
     }
+
     return -1;
   }
+
   Lexer.prototype = {
     nextChar: function Lexer_nextChar() {
       return this.currentChar = this.stream.getByte();
@@ -602,40 +752,56 @@ var Lexer = function LexerClosure() {
       var ch = this.currentChar;
       var eNotation = false;
       var divideBy = 0;
-      var sign = 1;
+      var sign = 0;
+
       if (ch === 0x2D) {
         sign = -1;
         ch = this.nextChar();
+
         if (ch === 0x2D) {
           ch = this.nextChar();
         }
       } else if (ch === 0x2B) {
+        sign = 1;
         ch = this.nextChar();
       }
-      if (ch === 0x2E) {
-        divideBy = 10;
-        ch = this.nextChar();
-      }
+
       if (ch === 0x0A || ch === 0x0D) {
         do {
           ch = this.nextChar();
         } while (ch === 0x0A || ch === 0x0D);
       }
+
+      if (ch === 0x2E) {
+        divideBy = 10;
+        ch = this.nextChar();
+      }
+
       if (ch < 0x30 || ch > 0x39) {
-        throw new _util.FormatError('Invalid number: ' + String.fromCharCode(ch) + ' (charCode ' + ch + ')');
+        if (divideBy === 10 && sign === 0 && ((0, _util.isSpace)(ch) || ch === -1)) {
+          (0, _util.warn)('Lexer.getNumber - treating a single decimal point as zero.');
+          return 0;
+        }
+
+        throw new _util.FormatError("Invalid number: ".concat(String.fromCharCode(ch), " (charCode ").concat(ch, ")"));
       }
+
+      sign = sign || 1;
       var baseValue = ch - 0x30;
       var powerValue = 0;
       var powerValueSign = 1;
+
       while ((ch = this.nextChar()) >= 0) {
         if (0x30 <= ch && ch <= 0x39) {
           var currentDigit = ch - 0x30;
+
           if (eNotation) {
             powerValue = powerValue * 10 + currentDigit;
           } else {
             if (divideBy !== 0) {
               divideBy *= 10;
             }
+
             baseValue = baseValue * 10 + currentDigit;
           }
         } else if (ch === 0x2E) {
@@ -648,23 +814,28 @@ var Lexer = function LexerClosure() {
           (0, _util.warn)('Badly formatted number');
         } else if (ch === 0x45 || ch === 0x65) {
           ch = this.peekChar();
+
           if (ch === 0x2B || ch === 0x2D) {
             powerValueSign = ch === 0x2D ? -1 : 1;
             this.nextChar();
           } else if (ch < 0x30 || ch > 0x39) {
             break;
           }
+
           eNotation = true;
         } else {
           break;
         }
       }
+
       if (divideBy !== 0) {
         baseValue /= divideBy;
       }
+
       if (eNotation) {
         baseValue *= Math.pow(10, powerValueSign * powerValue);
       }
+
       return sign * baseValue;
     },
     getString: function Lexer_getString() {
@@ -673,17 +844,21 @@ var Lexer = function LexerClosure() {
       var strBuf = this.strBuf;
       strBuf.length = 0;
       var ch = this.nextChar();
+
       while (true) {
         var charBuffered = false;
+
         switch (ch | 0) {
           case -1:
             (0, _util.warn)('Unterminated string');
             done = true;
             break;
+
           case 0x28:
             ++numParen;
             strBuf.push('(');
             break;
+
           case 0x29:
             if (--numParen === 0) {
               this.nextChar();
@@ -691,34 +866,44 @@ var Lexer = function LexerClosure() {
             } else {
               strBuf.push(')');
             }
+
             break;
+
           case 0x5C:
             ch = this.nextChar();
+
             switch (ch) {
               case -1:
                 (0, _util.warn)('Unterminated string');
                 done = true;
                 break;
+
               case 0x6E:
                 strBuf.push('\n');
                 break;
+
               case 0x72:
                 strBuf.push('\r');
                 break;
+
               case 0x74:
                 strBuf.push('\t');
                 break;
+
               case 0x62:
                 strBuf.push('\b');
                 break;
+
               case 0x66:
                 strBuf.push('\f');
                 break;
+
               case 0x5C:
               case 0x28:
               case 0x29:
                 strBuf.push(String.fromCharCode(ch));
                 break;
+
               case 0x30:
               case 0x31:
               case 0x32:
@@ -730,67 +915,87 @@ var Lexer = function LexerClosure() {
                 var x = ch & 0x0F;
                 ch = this.nextChar();
                 charBuffered = true;
+
                 if (ch >= 0x30 && ch <= 0x37) {
                   x = (x << 3) + (ch & 0x0F);
                   ch = this.nextChar();
+
                   if (ch >= 0x30 && ch <= 0x37) {
                     charBuffered = false;
                     x = (x << 3) + (ch & 0x0F);
                   }
                 }
+
                 strBuf.push(String.fromCharCode(x));
                 break;
+
               case 0x0D:
                 if (this.peekChar() === 0x0A) {
                   this.nextChar();
                 }
+
                 break;
+
               case 0x0A:
                 break;
+
               default:
                 strBuf.push(String.fromCharCode(ch));
                 break;
             }
+
             break;
+
           default:
             strBuf.push(String.fromCharCode(ch));
             break;
         }
+
         if (done) {
           break;
         }
+
         if (!charBuffered) {
           ch = this.nextChar();
         }
       }
+
       return strBuf.join('');
     },
     getName: function Lexer_getName() {
       var ch, previousCh;
       var strBuf = this.strBuf;
       strBuf.length = 0;
+
       while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) {
         if (ch === 0x23) {
           ch = this.nextChar();
+
           if (specialChars[ch]) {
             (0, _util.warn)('Lexer_getName: ' + 'NUMBER SIGN (#) should be followed by a hexadecimal number.');
             strBuf.push('#');
             break;
           }
+
           var x = toHexDigit(ch);
+
           if (x !== -1) {
             previousCh = ch;
             ch = this.nextChar();
             var x2 = toHexDigit(ch);
+
             if (x2 === -1) {
               (0, _util.warn)('Lexer_getName: Illegal digit (' + String.fromCharCode(ch) + ') in hexadecimal number.');
               strBuf.push('#', String.fromCharCode(previousCh));
+
               if (specialChars[ch]) {
                 break;
               }
+
               strBuf.push(String.fromCharCode(ch));
               continue;
             }
+
             strBuf.push(String.fromCharCode(x << 4 | x2));
           } else {
             strBuf.push('#', String.fromCharCode(ch));
@@ -799,9 +1004,11 @@ var Lexer = function LexerClosure() {
           strBuf.push(String.fromCharCode(ch));
         }
       }
+
       if (strBuf.length > 127) {
         (0, _util.warn)('name token is longer than allowed by the spec: ' + strBuf.length);
       }
+
       return _primitives.Name.get(strBuf.join(''));
     },
     getHexString: function Lexer_getHexString() {
@@ -811,6 +1018,7 @@ var Lexer = function LexerClosure() {
       var isFirstHex = true;
       var firstDigit;
       var secondDigit;
+
       while (true) {
         if (ch < 0) {
           (0, _util.warn)('Unterminated hex string');
@@ -824,6 +1032,7 @@ var Lexer = function LexerClosure() {
         } else {
           if (isFirstHex) {
             firstDigit = toHexDigit(ch);
+
             if (firstDigit === -1) {
               (0, _util.warn)('Ignoring invalid character "' + ch + '" in hex string');
               ch = this.nextChar();
@@ -831,26 +1040,32 @@ var Lexer = function LexerClosure() {
             }
           } else {
             secondDigit = toHexDigit(ch);
+
             if (secondDigit === -1) {
               (0, _util.warn)('Ignoring invalid character "' + ch + '" in hex string');
               ch = this.nextChar();
               continue;
             }
+
             strBuf.push(String.fromCharCode(firstDigit << 4 | secondDigit));
           }
+
           isFirstHex = !isFirstHex;
           ch = this.nextChar();
         }
       }
+
       return strBuf.join('');
     },
     getObj: function Lexer_getObj() {
       var comment = false;
       var ch = this.currentChar;
+
       while (true) {
         if (ch < 0) {
           return _primitives.EOF;
         }
+
         if (comment) {
           if (ch === 0x0A || ch === 0x0D) {
             comment = false;
@@ -860,8 +1075,10 @@ var Lexer = function LexerClosure() {
         } else if (specialChars[ch] !== 1) {
           break;
         }
+
         ch = this.nextChar();
       }
+
       switch (ch | 0) {
         case 0x30:
         case 0x31:
@@ -877,121 +1094,159 @@ var Lexer = function LexerClosure() {
         case 0x2D:
         case 0x2E:
           return this.getNumber();
+
         case 0x28:
           return this.getString();
+
         case 0x2F:
           return this.getName();
+
         case 0x5B:
           this.nextChar();
           return _primitives.Cmd.get('[');
+
         case 0x5D:
           this.nextChar();
           return _primitives.Cmd.get(']');
+
         case 0x3C:
           ch = this.nextChar();
+
           if (ch === 0x3C) {
             this.nextChar();
             return _primitives.Cmd.get('<<');
           }
+
           return this.getHexString();
+
         case 0x3E:
           ch = this.nextChar();
+
           if (ch === 0x3E) {
             this.nextChar();
             return _primitives.Cmd.get('>>');
           }
+
           return _primitives.Cmd.get('>');
+
         case 0x7B:
           this.nextChar();
           return _primitives.Cmd.get('{');
+
         case 0x7D:
           this.nextChar();
           return _primitives.Cmd.get('}');
+
         case 0x29:
           this.nextChar();
-          throw new _util.FormatError('Illegal character: ' + ch);
+          throw new _util.FormatError("Illegal character: ".concat(ch));
       }
+
       var str = String.fromCharCode(ch);
       var knownCommands = this.knownCommands;
       var knownCommandFound = knownCommands && knownCommands[str] !== undefined;
+
       while ((ch = this.nextChar()) >= 0 && !specialChars[ch]) {
         var possibleCommand = str + String.fromCharCode(ch);
+
         if (knownCommandFound && knownCommands[possibleCommand] === undefined) {
           break;
         }
+
         if (str.length === 128) {
-          throw new _util.FormatError('Command token too long: ' + str.length);
+          throw new _util.FormatError("Command token too long: ".concat(str.length));
         }
+
         str = possibleCommand;
         knownCommandFound = knownCommands && knownCommands[str] !== undefined;
       }
+
       if (str === 'true') {
         return true;
       }
+
       if (str === 'false') {
         return false;
       }
+
       if (str === 'null') {
         return null;
       }
+
       if (str === 'BI') {
         this.beginInlineImagePos = this.stream.pos;
       }
+
       return _primitives.Cmd.get(str);
     },
     skipToNextLine: function Lexer_skipToNextLine() {
       var ch = this.currentChar;
+
       while (ch >= 0) {
         if (ch === 0x0D) {
           ch = this.nextChar();
+
           if (ch === 0x0A) {
             this.nextChar();
           }
+
           break;
         } else if (ch === 0x0A) {
           this.nextChar();
           break;
         }
+
         ch = this.nextChar();
       }
     }
   };
   return Lexer;
 }();
+
+exports.Lexer = Lexer;
 var Linearization = {
   create: function LinearizationCreate(stream) {
     function getInt(name, allowZeroValue) {
       var obj = linDict.get(name);
+
       if (Number.isInteger(obj) && (allowZeroValue ? obj >= 0 : obj > 0)) {
         return obj;
       }
+
       throw new Error('The "' + name + '" parameter in the linearization ' + 'dictionary is invalid.');
     }
+
     function getHints() {
       var hints = linDict.get('H'),
           hintsLength,
           item;
+
       if (Array.isArray(hints) && ((hintsLength = hints.length) === 2 || hintsLength === 4)) {
         for (var index = 0; index < hintsLength; index++) {
           if (!(Number.isInteger(item = hints[index]) && item > 0)) {
             throw new Error('Hint (' + index + ') in the linearization dictionary is invalid.');
           }
         }
+
         return hints;
       }
+
       throw new Error('Hint array in the linearization dictionary is invalid.');
     }
+
     var parser = new Parser(new Lexer(stream), false, null);
     var obj1 = parser.getObj();
     var obj2 = parser.getObj();
     var obj3 = parser.getObj();
     var linDict = parser.getObj();
     var obj, length;
+
     if (!(Number.isInteger(obj1) && Number.isInteger(obj2) && (0, _primitives.isCmd)(obj3, 'obj') && (0, _primitives.isDict)(linDict) && (0, _util.isNum)(obj = linDict.get('Linearized')) && obj > 0)) {
       return null;
     } else if ((length = getInt('L')) !== stream.length) {
       throw new Error('The "L" parameter in the linearization dictionary ' + 'does not equal the stream length.');
     }
+
     return {
       length: length,
       hints: getHints(),
@@ -1003,6 +1258,4 @@ var Linearization = {
     };
   }
 };
-exports.Lexer = Lexer;
-exports.Linearization = Linearization;
-exports.Parser = Parser;
+exports.Linearization = Linearization;