pdfjs-dist 2.0.489 → 2.2.228

package/lib/test/unit/parser_spec.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 2019 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,88 +19,179 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
-var _parser = require('../../core/parser');
+var _parser = require("../../core/parser");
 
-var _primitives = require('../../core/primitives');
+var _util = require("../../shared/util");
 
-var _stream = require('../../core/stream');
+var _primitives = require("../../core/primitives");
+
+var _stream = require("../../core/stream");
 
 describe('parser', function () {
-  describe('Lexer', function () {
-    it('should stop parsing numbers at the end of stream', function () {
-      var input = new _stream.StringStream('11.234');
-      var lexer = new _parser.Lexer(input);
-      var result = lexer.getNumber();
-      expect(result).toEqual(11.234);
+  describe('Parser', function () {
+    describe('inlineStreamSkipEI', function () {
+      it('should skip over the EI marker if it is found', function () {
+        var string = 'q 1 0 0 1 0 0 cm BI /W 10 /H 10 /BPC 1 ' + '/F /A85 ID abc123~> EI Q';
+        var input = new _stream.StringStream(string);
+        var parser = new _parser.Parser({
+          lexer: new _parser.Lexer(input),
+          xref: null,
+          allowStreams: true
+        });
+        parser.inlineStreamSkipEI(input);
+        expect(input.pos).toEqual(string.indexOf('Q'));
+        expect(input.peekByte()).toEqual(0x51);
+      });
+      it('should skip to the end of stream if the EI marker is not found', function () {
+        var string = 'q 1 0 0 1 0 0 cm BI /W 10 /H 10 /BPC 1 ' + '/F /A85 ID abc123~> Q';
+        var input = new _stream.StringStream(string);
+        var parser = new _parser.Parser({
+          lexer: new _parser.Lexer(input),
+          xref: null,
+          allowStreams: true
+        });
+        parser.inlineStreamSkipEI(input);
+        expect(input.pos).toEqual(string.length);
+        expect(input.peekByte()).toEqual(-1);
+      });
     });
-    it('should parse PostScript numbers', function () {
-      var numbers = ['-.002', '34.5', '-3.62', '123.6e10', '1E-5', '-1.', '0.0', '123', '-98', '43445', '0', '+17'];
-      for (var i = 0, ii = numbers.length; i < ii; i++) {
-        var num = numbers[i];
-        var input = new _stream.StringStream(num);
+  });
+  describe('Lexer', function () {
+    describe('nextChar', function () {
+      it('should return and set -1 when the end of the stream is reached', function () {
+        var input = new _stream.StringStream('');
         var lexer = new _parser.Lexer(input);
-        var result = lexer.getNumber();
-        expect(result).toEqual(parseFloat(num));
-      }
-    });
-    it('should ignore double negative before number', function () {
-      var input = new _stream.StringStream('--205.88');
-      var lexer = new _parser.Lexer(input);
-      var result = lexer.getNumber();
-      expect(result).toEqual(-205.88);
-    });
-    it('should ignore minus signs in the middle of number', function () {
-      var input = new _stream.StringStream('205--.88');
-      var lexer = new _parser.Lexer(input);
-      var result = lexer.getNumber();
-      expect(result).toEqual(205.88);
-    });
-    it('should ignore line-breaks between operator and digit in number', function () {
-      var input = new _stream.StringStream('-\r\n205.88');
-      var lexer = new _parser.Lexer(input);
-      var result = lexer.getNumber();
-      expect(result).toEqual(-205.88);
-    });
-    it('should handle glued numbers and operators', function () {
-      var input = new _stream.StringStream('123ET');
-      var lexer = new _parser.Lexer(input);
-      var value = lexer.getNumber();
-      expect(value).toEqual(123);
-      expect(lexer.currentChar).toEqual(0x45);
+        expect(lexer.nextChar()).toEqual(-1);
+        expect(lexer.currentChar).toEqual(-1);
+      });
+      it('should return and set the character after the current position', function () {
+        var input = new _stream.StringStream('123');
+        var lexer = new _parser.Lexer(input);
+        expect(lexer.nextChar()).toEqual(0x32);
+        expect(lexer.currentChar).toEqual(0x32);
+      });
     });
-    it('should stop parsing strings at the end of stream', function () {
-      var input = new _stream.StringStream('(1$4)');
-      input.getByte = function (super_getByte) {
-        var ch = super_getByte.call(input);
-        return ch === 0x24 ? -1 : ch;
-      }.bind(input, input.getByte);
-      var lexer = new _parser.Lexer(input);
-      var result = lexer.getString();
-      expect(result).toEqual('1');
+    describe('peekChar', function () {
+      it('should only return -1 when the end of the stream is reached', function () {
+        var input = new _stream.StringStream('');
+        var lexer = new _parser.Lexer(input);
+        expect(lexer.peekChar()).toEqual(-1);
+        expect(lexer.currentChar).toEqual(-1);
+      });
+      it('should only return the character after the current position', function () {
+        var input = new _stream.StringStream('123');
+        var lexer = new _parser.Lexer(input);
+        expect(lexer.peekChar()).toEqual(0x32);
+        expect(lexer.currentChar).toEqual(0x31);
+      });
     });
-    it('should not throw exception on bad input', function () {
-      var input = new _stream.StringStream('<7 0 2 15 5 2 2 2 4 3 2 4>');
-      var lexer = new _parser.Lexer(input);
-      var result = lexer.getHexString();
-      expect(result).toEqual('p!U"$2');
+    describe('getNumber', function () {
+      it('should stop parsing numbers at the end of stream', function () {
+        var input = new _stream.StringStream('11.234');
+        var lexer = new _parser.Lexer(input);
+        expect(lexer.getNumber()).toEqual(11.234);
+      });
+      it('should parse PostScript numbers', function () {
+        var numbers = ['-.002', '34.5', '-3.62', '123.6e10', '1E-5', '-1.', '0.0', '123', '-98', '43445', '0', '+17'];
+
+        for (var _i = 0, _numbers = numbers; _i < _numbers.length; _i++) {
+          var number = _numbers[_i];
+          var input = new _stream.StringStream(number);
+          var lexer = new _parser.Lexer(input);
+          var result = lexer.getNumber(),
+              expected = parseFloat(number);
+
+          if (result !== expected && Math.abs(result - expected) < 1e-15) {
+            console.error("Fuzzy matching \"".concat(result, "\" with \"").concat(expected, "\" to ") + 'work-around rounding bugs in Chromium browsers.');
+            expect(true).toEqual(true);
+            continue;
+          }
+
+          expect(result).toEqual(expected);
+        }
+      });
+      it('should ignore double negative before number', function () {
+        var input = new _stream.StringStream('--205.88');
+        var lexer = new _parser.Lexer(input);
+        expect(lexer.getNumber()).toEqual(-205.88);
+      });
+      it('should ignore minus signs in the middle of number', function () {
+        var input = new _stream.StringStream('205--.88');
+        var lexer = new _parser.Lexer(input);
+        expect(lexer.getNumber()).toEqual(205.88);
+      });
+      it('should ignore line-breaks between operator and digit in number', function () {
+        var minusInput = new _stream.StringStream('-\r\n205.88');
+        var minusLexer = new _parser.Lexer(minusInput);
+        expect(minusLexer.getNumber()).toEqual(-205.88);
+        var plusInput = new _stream.StringStream('+\r\n205.88');
+        var plusLexer = new _parser.Lexer(plusInput);
+        expect(plusLexer.getNumber()).toEqual(205.88);
+      });
+      it('should treat a single decimal point as zero', function () {
+        var input = new _stream.StringStream('.');
+        var lexer = new _parser.Lexer(input);
+        expect(lexer.getNumber()).toEqual(0);
+        var numbers = ['..', '-.', '+.', '-\r\n.', '+\r\n.'];
+
+        var _loop = function _loop() {
+          var number = _numbers2[_i2];
+          var input = new _stream.StringStream(number);
+          var lexer = new _parser.Lexer(input);
+          expect(function () {
+            return lexer.getNumber();
+          }).toThrowError(_util.FormatError, /^Invalid number:\s/);
+        };
+
+        for (var _i2 = 0, _numbers2 = numbers; _i2 < _numbers2.length; _i2++) {
+          _loop();
+        }
+      });
+      it('should handle glued numbers and operators', function () {
+        var input = new _stream.StringStream('123ET');
+        var lexer = new _parser.Lexer(input);
+        expect(lexer.getNumber()).toEqual(123);
+        expect(lexer.currentChar).toEqual(0x45);
+      });
     });
-    it('should ignore escaped CR and LF', function () {
-      var input = new _stream.StringStream('(\\101\\\r\n\\102\\\r\\103\\\n\\104)');
-      var lexer = new _parser.Lexer(input);
-      var result = lexer.getString();
-      expect(result).toEqual('ABCD');
+    describe('getString', function () {
+      it('should stop parsing strings at the end of stream', function () {
+        var input = new _stream.StringStream('(1$4)');
+
+        input.getByte = function (super_getByte) {
+          var ch = super_getByte.call(input);
+          return ch === 0x24 ? -1 : ch;
+        }.bind(input, input.getByte);
+
+        var lexer = new _parser.Lexer(input);
+        expect(lexer.getString()).toEqual('1');
+      });
+      it('should ignore escaped CR and LF', function () {
+        var input = new _stream.StringStream('(\\101\\\r\n\\102\\\r\\103\\\n\\104)');
+        var lexer = new _parser.Lexer(input);
+        expect(lexer.getString()).toEqual('ABCD');
+      });
     });
-    it('should handle Names with invalid usage of NUMBER SIGN (#)', function () {
-      var inputNames = ['/# 680 0 R', '/#AQwerty', '/#A<</B'];
-      var expectedNames = ['#', '#AQwerty', '#A'];
-      for (var i = 0, ii = inputNames.length; i < ii; i++) {
-        var input = new _stream.StringStream(inputNames[i]);
+    describe('getHexString', function () {
+      it('should not throw exception on bad input', function () {
+        var input = new _stream.StringStream('<7 0 2 15 5 2 2 2 4 3 2 4>');
         var lexer = new _parser.Lexer(input);
-        var result = lexer.getName();
-        expect(result).toEqual(_primitives.Name.get(expectedNames[i]));
-      }
+        expect(lexer.getHexString()).toEqual('p!U"$2');
+      });
+    });
+    describe('getName', function () {
+      it('should handle Names with invalid usage of NUMBER SIGN (#)', function () {
+        var inputNames = ['/# 680 0 R', '/#AQwerty', '/#A<</B'];
+        var expectedNames = ['#', '#AQwerty', '#A'];
+
+        for (var i = 0, ii = inputNames.length; i < ii; i++) {
+          var input = new _stream.StringStream(inputNames[i]);
+          var lexer = new _parser.Lexer(input);
+          expect(lexer.getName()).toEqual(_primitives.Name.get(expectedNames[i]));
+        }
+      });
     });
   });
   describe('Linearization', function () {

package/lib/test/unit/pdf_find_controller_spec.js

@@ -0,0 +1,230 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * Javascript code in this page
+ *
+ * Copyright 2019 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @licend The above is the entire license notice for the
+ * Javascript code in this page
+ */
+"use strict";
+
+var _test_utils = require("./test_utils");
+
+var _ui_utils = require("../../web/ui_utils");
+
+var _api = require("../../display/api");
+
+var _pdf_find_controller = require("../../web/pdf_find_controller");
+
+var _pdf_link_service = require("../../web/pdf_link_service");
+
+function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
+
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
+
+function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
+
+function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+var MockLinkService =
+/*#__PURE__*/
+function (_SimpleLinkService) {
+  _inherits(MockLinkService, _SimpleLinkService);
+
+  function MockLinkService() {
+    var _this;
+
+    _classCallCheck(this, MockLinkService);
+
+    _this = _possibleConstructorReturn(this, _getPrototypeOf(MockLinkService).call(this));
+    _this._page = 1;
+    _this._pdfDocument = null;
+    return _this;
+  }
+
+  _createClass(MockLinkService, [{
+    key: "setDocument",
+    value: function setDocument(pdfDocument) {
+      this._pdfDocument = pdfDocument;
+    }
+  }, {
+    key: "pagesCount",
+    get: function get() {
+      return this._pdfDocument.numPages;
+    }
+  }, {
+    key: "page",
+    get: function get() {
+      return this._page;
+    },
+    set: function set(value) {
+      this._page = value;
+    }
+  }]);
+
+  return MockLinkService;
+}(_pdf_link_service.SimpleLinkService);
+
+describe('pdf_find_controller', function () {
+  var eventBus;
+  var pdfFindController;
+  beforeEach(function (done) {
+    var loadingTask = (0, _api.getDocument)((0, _test_utils.buildGetDocumentParams)('tracemonkey.pdf'));
+    loadingTask.promise.then(function (pdfDocument) {
+      eventBus = new _ui_utils.EventBus();
+      var linkService = new MockLinkService();
+      linkService.setDocument(pdfDocument);
+      pdfFindController = new _pdf_find_controller.PDFFindController({
+        linkService: linkService,
+        eventBus: eventBus
+      });
+      pdfFindController.setDocument(pdfDocument);
+      done();
+    });
+  });
+  afterEach(function () {
+    eventBus = null;
+    pdfFindController = null;
+  });
+
+  function testSearch(_ref) {
+    var parameters = _ref.parameters,
+        matchesPerPage = _ref.matchesPerPage,
+        selectedMatch = _ref.selectedMatch;
+    return new Promise(function (resolve) {
+      pdfFindController.executeCommand('find', parameters);
+      var totalPages = matchesPerPage.length;
+
+      for (var i = totalPages - 1; i >= 0; i--) {
+        if (matchesPerPage[i] > 0) {
+          totalPages = i + 1;
+          break;
+        }
+      }
+
+      var totalMatches = matchesPerPage.reduce(function (a, b) {
+        return a + b;
+      });
+      eventBus.on('updatefindmatchescount', function onUpdateFindMatchesCount(evt) {
+        if (pdfFindController.pageMatches.length !== totalPages) {
+          return;
+        }
+
+        eventBus.off('updatefindmatchescount', onUpdateFindMatchesCount);
+        expect(evt.matchesCount.total).toBe(totalMatches);
+
+        for (var _i = 0; _i < totalPages; _i++) {
+          expect(pdfFindController.pageMatches[_i].length).toEqual(matchesPerPage[_i]);
+        }
+
+        expect(pdfFindController.selected.pageIdx).toEqual(selectedMatch.pageIndex);
+        expect(pdfFindController.selected.matchIdx).toEqual(selectedMatch.matchIndex);
+        resolve();
+      });
+    });
+  }
+
+  it('performs a normal search', function (done) {
+    testSearch({
+      parameters: {
+        query: 'Dynamic',
+        caseSensitive: false,
+        entireWord: false,
+        phraseSearch: true,
+        findPrevious: false
+      },
+      matchesPerPage: [11, 5, 0, 3, 0, 0, 0, 1, 1, 1, 0, 3, 4, 4],
+      selectedMatch: {
+        pageIndex: 0,
+        matchIndex: 0
+      }
+    }).then(done);
+  });
+  it('performs a normal search and finds the previous result', function (done) {
+    testSearch({
+      parameters: {
+        query: 'conference',
+        caseSensitive: false,
+        entireWord: false,
+        phraseSearch: true,
+        findPrevious: true
+      },
+      matchesPerPage: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5],
+      selectedMatch: {
+        pageIndex: 13,
+        matchIndex: 4
+      }
+    }).then(done);
+  });
+  it('performs a case sensitive search', function (done) {
+    testSearch({
+      parameters: {
+        query: 'Dynamic',
+        caseSensitive: true,
+        entireWord: false,
+        phraseSearch: true,
+        findPrevious: false
+      },
+      matchesPerPage: [3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 3],
+      selectedMatch: {
+        pageIndex: 0,
+        matchIndex: 0
+      }
+    }).then(done);
+  });
+  it('performs an entire word search', function (done) {
+    testSearch({
+      parameters: {
+        query: 'Government',
+        caseSensitive: false,
+        entireWord: true,
+        phraseSearch: true,
+        findPrevious: false
+      },
+      matchesPerPage: [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+      selectedMatch: {
+        pageIndex: 12,
+        matchIndex: 0
+      }
+    }).then(done);
+  });
+  it('performs a multiple term (no phrase) search', function (done) {
+    testSearch({
+      parameters: {
+        query: 'alternate solution',
+        caseSensitive: false,
+        entireWord: false,
+        phraseSearch: false,
+        findPrevious: false
+      },
+      matchesPerPage: [0, 0, 0, 0, 0, 1, 0, 0, 4, 0, 0, 0, 0, 0],
+      selectedMatch: {
+        pageIndex: 5,
+        matchIndex: 0
+      }
+    }).then(done);
+  });
+});

package/lib/test/unit/pdf_find_utils_spec.js

@@ -0,0 +1,63 @@
+/**
+ * @licstart The following is the entire license notice for the
+ * Javascript code in this page
+ *
+ * Copyright 2019 Mozilla Foundation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * @licend The above is the entire license notice for the
+ * Javascript code in this page
+ */
+"use strict";
+
+var _pdf_find_utils = require("../../web/pdf_find_utils");
+
+describe('pdf_find_utils', function () {
+  describe('getCharacterType', function () {
+    it('gets expected character types', function () {
+      var characters = {
+        'A': _pdf_find_utils.CharacterType.ALPHA_LETTER,
+        'a': _pdf_find_utils.CharacterType.ALPHA_LETTER,
+        '0': _pdf_find_utils.CharacterType.ALPHA_LETTER,
+        '5': _pdf_find_utils.CharacterType.ALPHA_LETTER,
+        '\xC4': _pdf_find_utils.CharacterType.ALPHA_LETTER,
+        '\xE4': _pdf_find_utils.CharacterType.ALPHA_LETTER,
+        '_': _pdf_find_utils.CharacterType.ALPHA_LETTER,
+        ' ': _pdf_find_utils.CharacterType.SPACE,
+        '\t': _pdf_find_utils.CharacterType.SPACE,
+        '\r': _pdf_find_utils.CharacterType.SPACE,
+        '\n': _pdf_find_utils.CharacterType.SPACE,
+        '\xA0': _pdf_find_utils.CharacterType.SPACE,
+        '-': _pdf_find_utils.CharacterType.PUNCT,
+        ',': _pdf_find_utils.CharacterType.PUNCT,
+        '.': _pdf_find_utils.CharacterType.PUNCT,
+        ';': _pdf_find_utils.CharacterType.PUNCT,
+        ':': _pdf_find_utils.CharacterType.PUNCT,
+        "\u2122": _pdf_find_utils.CharacterType.ALPHA_LETTER,
+        "\u0E25": _pdf_find_utils.CharacterType.THAI_LETTER,
+        "\u4000": _pdf_find_utils.CharacterType.HAN_LETTER,
+        "\uF950": _pdf_find_utils.CharacterType.HAN_LETTER,
+        "\u30C0": _pdf_find_utils.CharacterType.KATAKANA_LETTER,
+        "\u3050": _pdf_find_utils.CharacterType.HIRAGANA_LETTER,
+        "\uFF80": _pdf_find_utils.CharacterType.HALFWIDTH_KATAKANA_LETTER
+      };
+
+      for (var character in characters) {
+        var charCode = character.charCodeAt(0);
+        var type = characters[character];
+        expect((0, _pdf_find_utils.getCharacterType)(charCode)).toEqual(type);
+      }
+    });
+  });
+});

package/lib/test/unit/pdf_history_spec.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 2019 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,9 +19,9 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
-var _pdf_history = require('../../web/pdf_history');
+var _pdf_history = require("../../web/pdf_history");
 
 describe('pdf_history', function () {
   describe('isDestHashesEqual', function () {
@@ -34,7 +34,9 @@ describe('pdf_history', function () {
       var destArrayString = JSON.stringify([{
         num: 3757,
         gen: 0
-      }, { name: 'XYZ' }, 92.918, 748.972, null]);
+      }, {
+        name: 'XYZ'
+      }, 92.918, 748.972, null]);
       expect((0, _pdf_history.isDestHashesEqual)(destArrayString, 'page.157')).toEqual(false);
       expect((0, _pdf_history.isDestHashesEqual)('page.157', destArrayString)).toEqual(false);
     });
@@ -48,23 +50,33 @@ describe('pdf_history', function () {
     var firstDest = [{
       num: 1,
       gen: 0
-    }, { name: 'XYZ' }, 0, 375, null];
+    }, {
+      name: 'XYZ'
+    }, 0, 375, null];
     var secondDest = [{
       num: 5,
       gen: 0
-    }, { name: 'XYZ' }, 0, 375, null];
+    }, {
+      name: 'XYZ'
+    }, 0, 375, null];
     var thirdDest = [{
       num: 1,
       gen: 0
-    }, { name: 'XYZ' }, 750, 0, null];
+    }, {
+      name: 'XYZ'
+    }, 750, 0, null];
     var fourthDest = [{
       num: 1,
       gen: 0
-    }, { name: 'XYZ' }, 0, 375, 1.0];
+    }, {
+      name: 'XYZ'
+    }, 0, 375, 1.0];
     var fifthDest = [{
       gen: 0,
       num: 1
-    }, { name: 'XYZ' }, 0, 375, null];
+    }, {
+      name: 'XYZ'
+    }, 0, 375, null];
     it('should reject non-equal destination arrays', function () {
       expect((0, _pdf_history.isDestArraysEqual)(firstDest, undefined)).toEqual(false);
       expect((0, _pdf_history.isDestArraysEqual)(firstDest, [1, 2, 3, 4, 5])).toEqual(false);