pdfjs-dist/lib/test/unit/annotation_spec.js

/* Copyright 2017 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.
 */
'use strict';
var corePrimitives = require('../../core/primitives.js');
var coreAnnotation = require('../../core/annotation.js');
var coreStream = require('../../core/stream.js');
var coreParser = require('../../core/parser.js');
var sharedUtil = require('../../shared/util.js');
var Annotation = coreAnnotation.Annotation;
var AnnotationBorderStyle = coreAnnotation.AnnotationBorderStyle;
var AnnotationFactory = coreAnnotation.AnnotationFactory;
var Lexer = coreParser.Lexer;
var Parser = coreParser.Parser;
var isRef = corePrimitives.isRef;
var Dict = corePrimitives.Dict;
var Name = corePrimitives.Name;
var Ref = corePrimitives.Ref;
var StringStream = coreStream.StringStream;
var AnnotationType = sharedUtil.AnnotationType;
var AnnotationFlag = sharedUtil.AnnotationFlag;
var AnnotationBorderStyleType = sharedUtil.AnnotationBorderStyleType;
var AnnotationFieldFlag = sharedUtil.AnnotationFieldFlag;
var stringToBytes = sharedUtil.stringToBytes;
var stringToUTF8String = sharedUtil.stringToUTF8String;
describe('annotation', function () {
 function XRefMock(array) {
  this.map = Object.create(null);
  for (var elem in array) {
   var obj = array[elem];
   var ref = obj.ref, data = obj.data;
   this.map[ref.toString()] = data;
  }
 }
 XRefMock.prototype = {
  fetch: function (ref) {
   return this.map[ref.toString()];
  },
  fetchIfRef: function (obj) {
   if (!isRef(obj)) {
    return obj;
   }
   return this.fetch(obj);
  }
 };
 function PDFManagerMock(params) {
  this.docBaseUrl = params.docBaseUrl || null;
 }
 PDFManagerMock.prototype = {};
 function IdFactoryMock(params) {
  var uniquePrefix = params.prefix || 'p0_';
  var idCounters = { obj: params.startObjId || 0 };
  return {
   createObjId: function () {
    return uniquePrefix + ++idCounters.obj;
   }
  };
 }
 IdFactoryMock.prototype = {};
 var annotationFactory, pdfManagerMock, idFactoryMock;
 beforeAll(function (done) {
  annotationFactory = new AnnotationFactory();
  pdfManagerMock = new PDFManagerMock({ docBaseUrl: null });
  idFactoryMock = new IdFactoryMock({});
  done();
 });
 afterAll(function () {
  annotationFactory = null;
  pdfManagerMock = null;
  idFactoryMock = null;
 });
 describe('AnnotationFactory', function () {
  it('should get id for annotation', function () {
   var annotationDict = new Dict();
   annotationDict.set('Type', Name.get('Annot'));
   annotationDict.set('Subtype', Name.get('Link'));
   var annotationRef = new Ref(10, 0);
   var xref = new XRefMock([{
     ref: annotationRef,
     data: annotationDict
    }]);
   var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.LINK);
   expect(data.id).toEqual('10R');
  });
  it('should handle, and get fallback id\'s for, annotations that are not ' + 'indirect objects (issue 7569)', function () {
   var annotationDict = new Dict();
   annotationDict.set('Type', Name.get('Annot'));
   annotationDict.set('Subtype', Name.get('Link'));
   var xref = new XRefMock();
   var idFactory = new IdFactoryMock({
    prefix: 'p0_',
    startObjId: 0
   });
   var annotation1 = annotationFactory.create(xref, annotationDict, pdfManagerMock, idFactory);
   var annotation2 = annotationFactory.create(xref, annotationDict, pdfManagerMock, idFactory);
   var data1 = annotation1.data, data2 = annotation2.data;
   expect(data1.annotationType).toEqual(AnnotationType.LINK);
   expect(data2.annotationType).toEqual(AnnotationType.LINK);
   expect(data1.id).toEqual('annot_p0_1');
   expect(data2.id).toEqual('annot_p0_2');
  });
  it('should handle missing /Subtype', function () {
   var annotationDict = new Dict();
   annotationDict.set('Type', Name.get('Annot'));
   var annotationRef = new Ref(1, 0);
   var xref = new XRefMock([{
     ref: annotationRef,
     data: annotationDict
    }]);
   var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toBeUndefined();
  });
 });
 describe('Annotation', function () {
  var dict, ref;
  beforeAll(function (done) {
   dict = new Dict();
   ref = new Ref(1, 0);
   done();
  });
  afterAll(function () {
   dict = ref = null;
  });
  it('should set and get flags', function () {
   var annotation = new Annotation({
    dict: dict,
    ref: ref
   });
   annotation.setFlags(13);
   expect(annotation.hasFlag(AnnotationFlag.INVISIBLE)).toEqual(true);
   expect(annotation.hasFlag(AnnotationFlag.NOZOOM)).toEqual(true);
   expect(annotation.hasFlag(AnnotationFlag.PRINT)).toEqual(true);
   expect(annotation.hasFlag(AnnotationFlag.READONLY)).toEqual(false);
  });
  it('should be viewable and not printable by default', function () {
   var annotation = new Annotation({
    dict: dict,
    ref: ref
   });
   expect(annotation.viewable).toEqual(true);
   expect(annotation.printable).toEqual(false);
  });
  it('should set and get a valid rectangle', function () {
   var annotation = new Annotation({
    dict: dict,
    ref: ref
   });
   annotation.setRectangle([
    117,
    694,
    164.298,
    720
   ]);
   expect(annotation.rectangle).toEqual([
    117,
    694,
    164.298,
    720
   ]);
  });
  it('should not set and get an invalid rectangle', function () {
   var annotation = new Annotation({
    dict: dict,
    ref: ref
   });
   annotation.setRectangle([
    117,
    694,
    164.298
   ]);
   expect(annotation.rectangle).toEqual([
    0,
    0,
    0,
    0
   ]);
  });
  it('should reject a color if it is not an array', function () {
   var annotation = new Annotation({
    dict: dict,
    ref: ref
   });
   annotation.setColor('red');
   expect(annotation.color).toEqual(new Uint8Array([
    0,
    0,
    0
   ]));
  });
  it('should set and get a transparent color', function () {
   var annotation = new Annotation({
    dict: dict,
    ref: ref
   });
   annotation.setColor([]);
   expect(annotation.color).toEqual(null);
  });
  it('should set and get a grayscale color', function () {
   var annotation = new Annotation({
    dict: dict,
    ref: ref
   });
   annotation.setColor([0.4]);
   expect(annotation.color).toEqual(new Uint8Array([
    102,
    102,
    102
   ]));
  });
  it('should set and get an RGB color', function () {
   var annotation = new Annotation({
    dict: dict,
    ref: ref
   });
   annotation.setColor([
    0,
    0,
    1
   ]);
   expect(annotation.color).toEqual(new Uint8Array([
    0,
    0,
    255
   ]));
  });
  it('should set and get a CMYK color', function () {
   var annotation = new Annotation({
    dict: dict,
    ref: ref
   });
   annotation.setColor([
    0.1,
    0.92,
    0.84,
    0.02
   ]);
   expect(annotation.color).toEqual(new Uint8Array([
    233,
    59,
    47
   ]));
  });
  it('should not set and get an invalid color', function () {
   var annotation = new Annotation({
    dict: dict,
    ref: ref
   });
   annotation.setColor([
    0.4,
    0.6
   ]);
   expect(annotation.color).toEqual(new Uint8Array([
    0,
    0,
    0
   ]));
  });
 });
 describe('AnnotationBorderStyle', function () {
  it('should set and get a valid width', function () {
   var borderStyle = new AnnotationBorderStyle();
   borderStyle.setWidth(3);
   expect(borderStyle.width).toEqual(3);
  });
  it('should not set and get an invalid width', function () {
   var borderStyle = new AnnotationBorderStyle();
   borderStyle.setWidth('three');
   expect(borderStyle.width).toEqual(1);
  });
  it('should set and get a valid style', function () {
   var borderStyle = new AnnotationBorderStyle();
   borderStyle.setStyle(Name.get('D'));
   expect(borderStyle.style).toEqual(AnnotationBorderStyleType.DASHED);
  });
  it('should not set and get an invalid style', function () {
   var borderStyle = new AnnotationBorderStyle();
   borderStyle.setStyle('Dashed');
   expect(borderStyle.style).toEqual(AnnotationBorderStyleType.SOLID);
  });
  it('should set and get a valid dash array', function () {
   var borderStyle = new AnnotationBorderStyle();
   borderStyle.setDashArray([
    1,
    2,
    3
   ]);
   expect(borderStyle.dashArray).toEqual([
    1,
    2,
    3
   ]);
  });
  it('should not set and get an invalid dash array', function () {
   var borderStyle = new AnnotationBorderStyle();
   borderStyle.setDashArray([
    0,
    0
   ]);
   expect(borderStyle.dashArray).toEqual([3]);
  });
  it('should set and get a valid horizontal corner radius', function () {
   var borderStyle = new AnnotationBorderStyle();
   borderStyle.setHorizontalCornerRadius(3);
   expect(borderStyle.horizontalCornerRadius).toEqual(3);
  });
  it('should not set and get an invalid horizontal corner radius', function () {
   var borderStyle = new AnnotationBorderStyle();
   borderStyle.setHorizontalCornerRadius('three');
   expect(borderStyle.horizontalCornerRadius).toEqual(0);
  });
  it('should set and get a valid vertical corner radius', function () {
   var borderStyle = new AnnotationBorderStyle();
   borderStyle.setVerticalCornerRadius(3);
   expect(borderStyle.verticalCornerRadius).toEqual(3);
  });
  it('should not set and get an invalid horizontal corner radius', function () {
   var borderStyle = new AnnotationBorderStyle();
   borderStyle.setVerticalCornerRadius('three');
   expect(borderStyle.verticalCornerRadius).toEqual(0);
  });
 });
 describe('LinkAnnotation', function () {
  it('should correctly parse a URI action', function () {
   var actionDict = new Dict();
   actionDict.set('Type', Name.get('Action'));
   actionDict.set('S', Name.get('URI'));
   actionDict.set('URI', 'http://www.ctan.org/tex-archive/info/lshort');
   var annotationDict = new Dict();
   annotationDict.set('Type', Name.get('Annot'));
   annotationDict.set('Subtype', Name.get('Link'));
   annotationDict.set('A', actionDict);
   var annotationRef = new Ref(820, 0);
   var xref = new XRefMock([{
     ref: annotationRef,
     data: annotationDict
    }]);
   var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.LINK);
   expect(data.url).toEqual('http://www.ctan.org/tex-archive/info/lshort');
   expect(data.unsafeUrl).toEqual('http://www.ctan.org/tex-archive/info/lshort');
   expect(data.dest).toBeUndefined();
  });
  it('should correctly parse a URI action, where the URI entry ' + 'is missing a protocol', function () {
   var actionDict = new Dict();
   actionDict.set('Type', Name.get('Action'));
   actionDict.set('S', Name.get('URI'));
   actionDict.set('URI', 'www.hmrc.gov.uk');
   var annotationDict = new Dict();
   annotationDict.set('Type', Name.get('Annot'));
   annotationDict.set('Subtype', Name.get('Link'));
   annotationDict.set('A', actionDict);
   var annotationRef = new Ref(353, 0);
   var xref = new XRefMock([{
     ref: annotationRef,
     data: annotationDict
    }]);
   var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.LINK);
   expect(data.url).toEqual('http://www.hmrc.gov.uk/');
   expect(data.unsafeUrl).toEqual('http://www.hmrc.gov.uk');
   expect(data.dest).toBeUndefined();
  });
  it('should correctly parse a URI action, where the URI entry ' + 'has an incorrect encoding (bug 1122280)', function () {
   var actionStream = new StringStream('<<\n' + '/Type /Action\n' + '/S /URI\n' + '/URI (http://www.example.com/\\303\\274\\303\\266\\303\\244)\n' + '>>\n');
   var lexer = new Lexer(actionStream);
   var parser = new Parser(lexer);
   var actionDict = parser.getObj();
   var annotationDict = new Dict();
   annotationDict.set('Type', Name.get('Annot'));
   annotationDict.set('Subtype', Name.get('Link'));
   annotationDict.set('A', actionDict);
   var annotationRef = new Ref(8, 0);
   var xref = new XRefMock([{
     ref: annotationRef,
     data: annotationDict
    }]);
   var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.LINK);
   expect(data.url).toEqual(new URL(stringToUTF8String('http://www.example.com/\xC3\xBC\xC3\xB6\xC3\xA4')).href);
   expect(data.unsafeUrl).toEqual(stringToUTF8String('http://www.example.com/\xC3\xBC\xC3\xB6\xC3\xA4'));
   expect(data.dest).toBeUndefined();
  });
  it('should correctly parse a GoTo action', function () {
   var actionDict = new Dict();
   actionDict.set('Type', Name.get('Action'));
   actionDict.set('S', Name.get('GoTo'));
   actionDict.set('D', 'page.157');
   var annotationDict = new Dict();
   annotationDict.set('Type', Name.get('Annot'));
   annotationDict.set('Subtype', Name.get('Link'));
   annotationDict.set('A', actionDict);
   var annotationRef = new Ref(798, 0);
   var xref = new XRefMock([{
     ref: annotationRef,
     data: annotationDict
    }]);
   var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.LINK);
   expect(data.url).toBeUndefined();
   expect(data.unsafeUrl).toBeUndefined();
   expect(data.dest).toEqual('page.157');
  });
  it('should correctly parse a GoToR action, where the FileSpec entry ' + 'is a string containing a relative URL', function () {
   var actionDict = new Dict();
   actionDict.set('Type', Name.get('Action'));
   actionDict.set('S', Name.get('GoToR'));
   actionDict.set('F', '../../0013/001346/134685E.pdf');
   actionDict.set('D', '4.3');
   actionDict.set('NewWindow', true);
   var annotationDict = new Dict();
   annotationDict.set('Type', Name.get('Annot'));
   annotationDict.set('Subtype', Name.get('Link'));
   annotationDict.set('A', actionDict);
   var annotationRef = new Ref(489, 0);
   var xref = new XRefMock([{
     ref: annotationRef,
     data: annotationDict
    }]);
   var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.LINK);
   expect(data.url).toBeUndefined();
   expect(data.unsafeUrl).toEqual('../../0013/001346/134685E.pdf#4.3');
   expect(data.dest).toBeUndefined();
   expect(data.newWindow).toEqual(true);
  });
  it('should correctly parse a GoToR action, containing a relative URL, ' + 'with the "docBaseUrl" parameter specified', function () {
   var actionDict = new Dict();
   actionDict.set('Type', Name.get('Action'));
   actionDict.set('S', Name.get('GoToR'));
   actionDict.set('F', '../../0013/001346/134685E.pdf');
   actionDict.set('D', '4.3');
   var annotationDict = new Dict();
   annotationDict.set('Type', Name.get('Annot'));
   annotationDict.set('Subtype', Name.get('Link'));
   annotationDict.set('A', actionDict);
   var annotationRef = new Ref(489, 0);
   var xref = new XRefMock([{
     ref: annotationRef,
     data: annotationDict
    }]);
   var pdfManager = new PDFManagerMock({ docBaseUrl: 'http://www.example.com/test/pdfs/qwerty.pdf' });
   var annotation = annotationFactory.create(xref, annotationRef, pdfManager, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.LINK);
   expect(data.url).toEqual('http://www.example.com/0013/001346/134685E.pdf#4.3');
   expect(data.unsafeUrl).toEqual('../../0013/001346/134685E.pdf#4.3');
   expect(data.dest).toBeUndefined();
  });
  it('should correctly parse a GoToR action, with named destination', function () {
   var actionDict = new Dict();
   actionDict.set('Type', Name.get('Action'));
   actionDict.set('S', Name.get('GoToR'));
   actionDict.set('F', 'http://www.example.com/test.pdf');
   actionDict.set('D', '15');
   var annotationDict = new Dict();
   annotationDict.set('Type', Name.get('Annot'));
   annotationDict.set('Subtype', Name.get('Link'));
   annotationDict.set('A', actionDict);
   var annotationRef = new Ref(495, 0);
   var xref = new XRefMock([{
     ref: annotationRef,
     data: annotationDict
    }]);
   var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.LINK);
   expect(data.url).toEqual('http://www.example.com/test.pdf#nameddest=15');
   expect(data.unsafeUrl).toEqual('http://www.example.com/test.pdf#nameddest=15');
   expect(data.dest).toBeUndefined();
   expect(data.newWindow).toBeFalsy();
  });
  it('should correctly parse a GoToR action, with explicit destination array', function () {
   var actionDict = new Dict();
   actionDict.set('Type', Name.get('Action'));
   actionDict.set('S', Name.get('GoToR'));
   actionDict.set('F', 'http://www.example.com/test.pdf');
   actionDict.set('D', [
    14,
    Name.get('XYZ'),
    null,
    298.043,
    null
   ]);
   var annotationDict = new Dict();
   annotationDict.set('Type', Name.get('Annot'));
   annotationDict.set('Subtype', Name.get('Link'));
   annotationDict.set('A', actionDict);
   var annotationRef = new Ref(489, 0);
   var xref = new XRefMock([{
     ref: annotationRef,
     data: annotationDict
    }]);
   var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.LINK);
   expect(data.url).toEqual(new URL('http://www.example.com/test.pdf#' + '[14,{"name":"XYZ"},null,298.043,null]').href);
   expect(data.unsafeUrl).toEqual('http://www.example.com/test.pdf#' + '[14,{"name":"XYZ"},null,298.043,null]');
   expect(data.dest).toBeUndefined();
   expect(data.newWindow).toBeFalsy();
  });
  it('should correctly parse a Launch action, where the FileSpec dict ' + 'contains a relative URL, with the "docBaseUrl" parameter specified', function () {
   var fileSpecDict = new Dict();
   fileSpecDict.set('Type', Name.get('FileSpec'));
   fileSpecDict.set('F', 'Part II/Part II.pdf');
   fileSpecDict.set('UF', 'Part II/Part II.pdf');
   var actionDict = new Dict();
   actionDict.set('Type', Name.get('Action'));
   actionDict.set('S', Name.get('Launch'));
   actionDict.set('F', fileSpecDict);
   actionDict.set('NewWindow', true);
   var annotationDict = new Dict();
   annotationDict.set('Type', Name.get('Annot'));
   annotationDict.set('Subtype', Name.get('Link'));
   annotationDict.set('A', actionDict);
   var annotationRef = new Ref(88, 0);
   var xref = new XRefMock([{
     ref: annotationRef,
     data: annotationDict
    }]);
   var pdfManager = new PDFManagerMock({ docBaseUrl: 'http://www.example.com/test/pdfs/qwerty.pdf' });
   var annotation = annotationFactory.create(xref, annotationRef, pdfManager, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.LINK);
   expect(data.url).toEqual(new URL('http://www.example.com/test/pdfs/Part II/Part II.pdf').href);
   expect(data.unsafeUrl).toEqual('Part II/Part II.pdf');
   expect(data.dest).toBeUndefined();
   expect(data.newWindow).toEqual(true);
  });
  it('should recover valid URLs from JavaScript actions having certain ' + 'white-listed formats', function () {
   function checkJsAction(params) {
    var jsEntry = params.jsEntry;
    var expectedUrl = params.expectedUrl;
    var expectedUnsafeUrl = params.expectedUnsafeUrl;
    var expectedNewWindow = params.expectedNewWindow;
    var actionDict = new Dict();
    actionDict.set('Type', Name.get('Action'));
    actionDict.set('S', Name.get('JavaScript'));
    actionDict.set('JS', jsEntry);
    var annotationDict = new Dict();
    annotationDict.set('Type', Name.get('Annot'));
    annotationDict.set('Subtype', Name.get('Link'));
    annotationDict.set('A', actionDict);
    var annotationRef = new Ref(46, 0);
    var xref = new XRefMock([{
      ref: annotationRef,
      data: annotationDict
     }]);
    var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
    var data = annotation.data;
    expect(data.annotationType).toEqual(AnnotationType.LINK);
    expect(data.url).toEqual(expectedUrl);
    expect(data.unsafeUrl).toEqual(expectedUnsafeUrl);
    expect(data.dest).toBeUndefined();
    expect(data.newWindow).toEqual(expectedNewWindow);
   }
   checkJsAction({
    jsEntry: 'function someFun() { return "qwerty"; } someFun();',
    expectedUrl: undefined,
    expectedUnsafeUrl: undefined,
    expectedNewWindow: undefined
   });
   checkJsAction({
    jsEntry: 'window.open(\'http://www.example.com/test.pdf\')',
    expectedUrl: new URL('http://www.example.com/test.pdf').href,
    expectedUnsafeUrl: 'http://www.example.com/test.pdf',
    expectedNewWindow: undefined
   });
   checkJsAction({
    jsEntry: new StringStream('app.launchURL("http://www.example.com/test.pdf", true)'),
    expectedUrl: new URL('http://www.example.com/test.pdf').href,
    expectedUnsafeUrl: 'http://www.example.com/test.pdf',
    expectedNewWindow: true
   });
  });
  it('should correctly parse a Named action', function () {
   var actionDict = new Dict();
   actionDict.set('Type', Name.get('Action'));
   actionDict.set('S', Name.get('Named'));
   actionDict.set('N', Name.get('GoToPage'));
   var annotationDict = new Dict();
   annotationDict.set('Type', Name.get('Annot'));
   annotationDict.set('Subtype', Name.get('Link'));
   annotationDict.set('A', actionDict);
   var annotationRef = new Ref(12, 0);
   var xref = new XRefMock([{
     ref: annotationRef,
     data: annotationDict
    }]);
   var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.LINK);
   expect(data.url).toBeUndefined();
   expect(data.unsafeUrl).toBeUndefined();
   expect(data.action).toEqual('GoToPage');
  });
  it('should correctly parse a simple Dest', function () {
   var annotationDict = new Dict();
   annotationDict.set('Type', Name.get('Annot'));
   annotationDict.set('Subtype', Name.get('Link'));
   annotationDict.set('Dest', Name.get('LI0'));
   var annotationRef = new Ref(583, 0);
   var xref = new XRefMock([{
     ref: annotationRef,
     data: annotationDict
    }]);
   var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.LINK);
   expect(data.url).toBeUndefined();
   expect(data.unsafeUrl).toBeUndefined();
   expect(data.dest).toEqual('LI0');
  });
  it('should correctly parse a simple Dest, with explicit destination array', function () {
   var annotationDict = new Dict();
   annotationDict.set('Type', Name.get('Annot'));
   annotationDict.set('Subtype', Name.get('Link'));
   annotationDict.set('Dest', [
    new Ref(17, 0),
    Name.get('XYZ'),
    0,
    841.89,
    null
   ]);
   var annotationRef = new Ref(10, 0);
   var xref = new XRefMock([{
     ref: annotationRef,
     data: annotationDict
    }]);
   var annotation = annotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.LINK);
   expect(data.url).toBeUndefined();
   expect(data.unsafeUrl).toBeUndefined();
   expect(data.dest).toEqual([
    {
     num: 17,
     gen: 0
    },
    { name: 'XYZ' },
    0,
    841.89,
    null
   ]);
  });
 });
 describe('WidgetAnnotation', function () {
  var widgetDict;
  beforeEach(function (done) {
   widgetDict = new Dict();
   widgetDict.set('Type', Name.get('Annot'));
   widgetDict.set('Subtype', Name.get('Widget'));
   done();
  });
  afterEach(function () {
   widgetDict = null;
  });
  it('should handle unknown field names', function () {
   var widgetRef = new Ref(20, 0);
   var xref = new XRefMock([{
     ref: widgetRef,
     data: widgetDict
    }]);
   var annotation = annotationFactory.create(xref, widgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.fieldName).toEqual('');
  });
  it('should construct the field name when there are no ancestors', function () {
   widgetDict.set('T', 'foo');
   var widgetRef = new Ref(21, 0);
   var xref = new XRefMock([{
     ref: widgetRef,
     data: widgetDict
    }]);
   var annotation = annotationFactory.create(xref, widgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.fieldName).toEqual('foo');
  });
  it('should construct the field name when there are ancestors', function () {
   var firstParent = new Dict();
   firstParent.set('T', 'foo');
   var secondParent = new Dict();
   secondParent.set('Parent', firstParent);
   secondParent.set('T', 'bar');
   widgetDict.set('Parent', secondParent);
   widgetDict.set('T', 'baz');
   var widgetRef = new Ref(22, 0);
   var xref = new XRefMock([{
     ref: widgetRef,
     data: widgetDict
    }]);
   var annotation = annotationFactory.create(xref, widgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.fieldName).toEqual('foo.bar.baz');
  });
 });
 describe('TextWidgetAnnotation', function () {
  var textWidgetDict;
  beforeEach(function (done) {
   textWidgetDict = new Dict();
   textWidgetDict.set('Type', Name.get('Annot'));
   textWidgetDict.set('Subtype', Name.get('Widget'));
   textWidgetDict.set('FT', Name.get('Tx'));
   done();
  });
  afterEach(function () {
   textWidgetDict = null;
  });
  it('should handle unknown text alignment, maximum length and flags', function () {
   var textWidgetRef = new Ref(124, 0);
   var xref = new XRefMock([{
     ref: textWidgetRef,
     data: textWidgetDict
    }]);
   var annotation = annotationFactory.create(xref, textWidgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.textAlignment).toEqual(null);
   expect(data.maxLen).toEqual(null);
   expect(data.readOnly).toEqual(false);
   expect(data.multiLine).toEqual(false);
   expect(data.comb).toEqual(false);
  });
  it('should not set invalid text alignment, maximum length and flags', function () {
   textWidgetDict.set('Q', 'center');
   textWidgetDict.set('MaxLen', 'five');
   textWidgetDict.set('Ff', 'readonly');
   var textWidgetRef = new Ref(43, 0);
   var xref = new XRefMock([{
     ref: textWidgetRef,
     data: textWidgetDict
    }]);
   var annotation = annotationFactory.create(xref, textWidgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.textAlignment).toEqual(null);
   expect(data.maxLen).toEqual(null);
   expect(data.readOnly).toEqual(false);
   expect(data.multiLine).toEqual(false);
   expect(data.comb).toEqual(false);
  });
  it('should set valid text alignment, maximum length and flags', function () {
   textWidgetDict.set('Q', 1);
   textWidgetDict.set('MaxLen', 20);
   textWidgetDict.set('Ff', AnnotationFieldFlag.READONLY + AnnotationFieldFlag.MULTILINE);
   var textWidgetRef = new Ref(84, 0);
   var xref = new XRefMock([{
     ref: textWidgetRef,
     data: textWidgetDict
    }]);
   var annotation = annotationFactory.create(xref, textWidgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.textAlignment).toEqual(1);
   expect(data.maxLen).toEqual(20);
   expect(data.readOnly).toEqual(true);
   expect(data.multiLine).toEqual(true);
  });
  it('should reject comb fields without a maximum length', function () {
   textWidgetDict.set('Ff', AnnotationFieldFlag.COMB);
   var textWidgetRef = new Ref(46, 0);
   var xref = new XRefMock([{
     ref: textWidgetRef,
     data: textWidgetDict
    }]);
   var annotation = annotationFactory.create(xref, textWidgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.comb).toEqual(false);
  });
  it('should accept comb fields with a maximum length', function () {
   textWidgetDict.set('MaxLen', 20);
   textWidgetDict.set('Ff', AnnotationFieldFlag.COMB);
   var textWidgetRef = new Ref(46, 0);
   var xref = new XRefMock([{
     ref: textWidgetRef,
     data: textWidgetDict
    }]);
   var annotation = annotationFactory.create(xref, textWidgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.comb).toEqual(true);
  });
  it('should only accept comb fields when the flags are valid', function () {
   var invalidFieldFlags = [
    AnnotationFieldFlag.MULTILINE,
    AnnotationFieldFlag.PASSWORD,
    AnnotationFieldFlag.FILESELECT
   ];
   var flags = AnnotationFieldFlag.COMB + AnnotationFieldFlag.MULTILINE + AnnotationFieldFlag.PASSWORD + AnnotationFieldFlag.FILESELECT;
   for (var i = 0, ii = invalidFieldFlags.length; i <= ii; i++) {
    textWidgetDict.set('MaxLen', 20);
    textWidgetDict.set('Ff', flags);
    var textWidgetRef = new Ref(93, 0);
    var xref = new XRefMock([{
      ref: textWidgetRef,
      data: textWidgetDict
     }]);
    var annotation = annotationFactory.create(xref, textWidgetRef, pdfManagerMock, idFactoryMock);
    var data = annotation.data;
    expect(data.annotationType).toEqual(AnnotationType.WIDGET);
    var valid = invalidFieldFlags.length === 0;
    expect(data.comb).toEqual(valid);
    if (!valid) {
     flags -= invalidFieldFlags.splice(-1, 1);
    }
   }
  });
 });
 describe('ButtonWidgetAnnotation', function () {
  var buttonWidgetDict;
  beforeEach(function (done) {
   buttonWidgetDict = new Dict();
   buttonWidgetDict.set('Type', Name.get('Annot'));
   buttonWidgetDict.set('Subtype', Name.get('Widget'));
   buttonWidgetDict.set('FT', Name.get('Btn'));
   done();
  });
  afterEach(function () {
   buttonWidgetDict = null;
  });
  it('should handle checkboxes', function () {
   buttonWidgetDict.set('V', Name.get('1'));
   var buttonWidgetRef = new Ref(124, 0);
   var xref = new XRefMock([{
     ref: buttonWidgetRef,
     data: buttonWidgetDict
    }]);
   var annotation = annotationFactory.create(xref, buttonWidgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.checkBox).toEqual(true);
   expect(data.fieldValue).toEqual('1');
   expect(data.radioButton).toEqual(false);
  });
  it('should handle radio buttons with a field value', function () {
   var parentDict = new Dict();
   parentDict.set('V', Name.get('1'));
   var normalAppearanceStateDict = new Dict();
   normalAppearanceStateDict.set('2', null);
   var appearanceStatesDict = new Dict();
   appearanceStatesDict.set('N', normalAppearanceStateDict);
   buttonWidgetDict.set('Ff', AnnotationFieldFlag.RADIO);
   buttonWidgetDict.set('Parent', parentDict);
   buttonWidgetDict.set('AP', appearanceStatesDict);
   var buttonWidgetRef = new Ref(124, 0);
   var xref = new XRefMock([{
     ref: buttonWidgetRef,
     data: buttonWidgetDict
    }]);
   var annotation = annotationFactory.create(xref, buttonWidgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.checkBox).toEqual(false);
   expect(data.radioButton).toEqual(true);
   expect(data.fieldValue).toEqual('1');
   expect(data.buttonValue).toEqual('2');
  });
  it('should handle radio buttons without a field value', function () {
   var normalAppearanceStateDict = new Dict();
   normalAppearanceStateDict.set('2', null);
   var appearanceStatesDict = new Dict();
   appearanceStatesDict.set('N', normalAppearanceStateDict);
   buttonWidgetDict.set('Ff', AnnotationFieldFlag.RADIO);
   buttonWidgetDict.set('AP', appearanceStatesDict);
   var buttonWidgetRef = new Ref(124, 0);
   var xref = new XRefMock([{
     ref: buttonWidgetRef,
     data: buttonWidgetDict
    }]);
   var annotation = annotationFactory.create(xref, buttonWidgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.checkBox).toEqual(false);
   expect(data.radioButton).toEqual(true);
   expect(data.fieldValue).toEqual(null);
   expect(data.buttonValue).toEqual('2');
  });
 });
 describe('ChoiceWidgetAnnotation', function () {
  var choiceWidgetDict;
  beforeEach(function (done) {
   choiceWidgetDict = new Dict();
   choiceWidgetDict.set('Type', Name.get('Annot'));
   choiceWidgetDict.set('Subtype', Name.get('Widget'));
   choiceWidgetDict.set('FT', Name.get('Ch'));
   done();
  });
  afterEach(function () {
   choiceWidgetDict = null;
  });
  it('should handle missing option arrays', function () {
   var choiceWidgetRef = new Ref(122, 0);
   var xref = new XRefMock([{
     ref: choiceWidgetRef,
     data: choiceWidgetDict
    }]);
   var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.options).toEqual([]);
  });
  it('should handle option arrays with array elements', function () {
   var optionBarRef = new Ref(20, 0);
   var optionBarStr = 'Bar';
   var optionOneRef = new Ref(10, 0);
   var optionOneArr = [
    'bar_export',
    optionBarRef
   ];
   var options = [
    [
     'foo_export',
     'Foo'
    ],
    optionOneRef
   ];
   var expected = [
    {
     exportValue: 'foo_export',
     displayValue: 'Foo'
    },
    {
     exportValue: 'bar_export',
     displayValue: 'Bar'
    }
   ];
   choiceWidgetDict.set('Opt', options);
   var choiceWidgetRef = new Ref(123, 0);
   var xref = new XRefMock([
    {
     ref: choiceWidgetRef,
     data: choiceWidgetDict
    },
    {
     ref: optionBarRef,
     data: optionBarStr
    },
    {
     ref: optionOneRef,
     data: optionOneArr
    }
   ]);
   var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.options).toEqual(expected);
  });
  it('should handle option arrays with string elements', function () {
   var optionBarRef = new Ref(10, 0);
   var optionBarStr = 'Bar';
   var options = [
    'Foo',
    optionBarRef
   ];
   var expected = [
    {
     exportValue: 'Foo',
     displayValue: 'Foo'
    },
    {
     exportValue: 'Bar',
     displayValue: 'Bar'
    }
   ];
   choiceWidgetDict.set('Opt', options);
   var choiceWidgetRef = new Ref(981, 0);
   var xref = new XRefMock([
    {
     ref: choiceWidgetRef,
     data: choiceWidgetDict
    },
    {
     ref: optionBarRef,
     data: optionBarStr
    }
   ]);
   var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.options).toEqual(expected);
  });
  it('should handle inherited option arrays (issue 8094)', function () {
   var options = [
    [
     'Value1',
     'Description1'
    ],
    [
     'Value2',
     'Description2'
    ]
   ];
   var expected = [
    {
     exportValue: 'Value1',
     displayValue: 'Description1'
    },
    {
     exportValue: 'Value2',
     displayValue: 'Description2'
    }
   ];
   var parentDict = new Dict();
   parentDict.set('Opt', options);
   choiceWidgetDict.set('Parent', parentDict);
   var choiceWidgetRef = new Ref(123, 0);
   var xref = new XRefMock([{
     ref: choiceWidgetRef,
     data: choiceWidgetDict
    }]);
   var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.options).toEqual(expected);
  });
  it('should handle array field values', function () {
   var fieldValue = [
    'Foo',
    'Bar'
   ];
   choiceWidgetDict.set('V', fieldValue);
   var choiceWidgetRef = new Ref(968, 0);
   var xref = new XRefMock([{
     ref: choiceWidgetRef,
     data: choiceWidgetDict
    }]);
   var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.fieldValue).toEqual(fieldValue);
  });
  it('should handle string field values', function () {
   var fieldValue = 'Foo';
   choiceWidgetDict.set('V', fieldValue);
   var choiceWidgetRef = new Ref(978, 0);
   var xref = new XRefMock([{
     ref: choiceWidgetRef,
     data: choiceWidgetDict
    }]);
   var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.fieldValue).toEqual([fieldValue]);
  });
  it('should handle unknown flags', function () {
   var choiceWidgetRef = new Ref(166, 0);
   var xref = new XRefMock([{
     ref: choiceWidgetRef,
     data: choiceWidgetDict
    }]);
   var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.readOnly).toEqual(false);
   expect(data.combo).toEqual(false);
   expect(data.multiSelect).toEqual(false);
  });
  it('should not set invalid flags', function () {
   choiceWidgetDict.set('Ff', 'readonly');
   var choiceWidgetRef = new Ref(165, 0);
   var xref = new XRefMock([{
     ref: choiceWidgetRef,
     data: choiceWidgetDict
    }]);
   var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.readOnly).toEqual(false);
   expect(data.combo).toEqual(false);
   expect(data.multiSelect).toEqual(false);
  });
  it('should set valid flags', function () {
   choiceWidgetDict.set('Ff', AnnotationFieldFlag.READONLY + AnnotationFieldFlag.COMBO + AnnotationFieldFlag.MULTISELECT);
   var choiceWidgetRef = new Ref(512, 0);
   var xref = new XRefMock([{
     ref: choiceWidgetRef,
     data: choiceWidgetDict
    }]);
   var annotation = annotationFactory.create(xref, choiceWidgetRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.WIDGET);
   expect(data.readOnly).toEqual(true);
   expect(data.combo).toEqual(true);
   expect(data.multiSelect).toEqual(true);
  });
 });
 describe('FileAttachmentAnnotation', function () {
  it('should correctly parse a file attachment', function () {
   var fileStream = new StringStream('<<\n' + '/Type /EmbeddedFile\n' + '/Subtype /text#2Fplain\n' + '>>\n' + 'stream\n' + 'Test attachment' + 'endstream\n');
   var lexer = new Lexer(fileStream);
   var parser = new Parser(lexer, true);
   var fileStreamRef = new Ref(18, 0);
   var fileStreamDict = parser.getObj();
   var embeddedFileDict = new Dict();
   embeddedFileDict.set('F', fileStreamRef);
   var fileSpecRef = new Ref(19, 0);
   var fileSpecDict = new Dict();
   fileSpecDict.set('Type', Name.get('Filespec'));
   fileSpecDict.set('Desc', '');
   fileSpecDict.set('EF', embeddedFileDict);
   fileSpecDict.set('UF', 'Test.txt');
   var fileAttachmentRef = new Ref(20, 0);
   var fileAttachmentDict = new Dict();
   fileAttachmentDict.set('Type', Name.get('Annot'));
   fileAttachmentDict.set('Subtype', Name.get('FileAttachment'));
   fileAttachmentDict.set('FS', fileSpecRef);
   fileAttachmentDict.set('T', 'Topic');
   fileAttachmentDict.set('Contents', 'Test.txt');
   var xref = new XRefMock([
    {
     ref: fileStreamRef,
     data: fileStreamDict
    },
    {
     ref: fileSpecRef,
     data: fileSpecDict
    },
    {
     ref: fileAttachmentRef,
     data: fileAttachmentDict
    }
   ]);
   embeddedFileDict.assignXref(xref);
   fileSpecDict.assignXref(xref);
   fileAttachmentDict.assignXref(xref);
   var annotation = annotationFactory.create(xref, fileAttachmentRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.FILEATTACHMENT);
   expect(data.file.filename).toEqual('Test.txt');
   expect(data.file.content).toEqual(stringToBytes('Test attachment'));
  });
 });
 describe('PopupAnnotation', function () {
  it('should inherit the parent flags when the Popup is not viewable, ' + 'but the parent is (PR 7352)', function () {
   var parentDict = new Dict();
   parentDict.set('Type', Name.get('Annot'));
   parentDict.set('Subtype', Name.get('Text'));
   parentDict.set('F', 28);
   var popupDict = new Dict();
   popupDict.set('Type', Name.get('Annot'));
   popupDict.set('Subtype', Name.get('Popup'));
   popupDict.set('F', 25);
   popupDict.set('Parent', parentDict);
   var popupRef = new Ref(13, 0);
   var xref = new XRefMock([{
     ref: popupRef,
     data: popupDict
    }]);
   var annotation = annotationFactory.create(xref, popupRef, pdfManagerMock, idFactoryMock);
   var data = annotation.data;
   expect(data.annotationType).toEqual(AnnotationType.POPUP);
   expect(data.annotationFlags).toEqual(25);
   expect(annotation.viewable).toEqual(true);
  });
 });
});