pdfjs-dist
Version:
Generic build of Mozilla's PDF.js library.
1,187 lines (1,186 loc) • 151 kB
JavaScript
/**
* @licstart The following is the entire license notice for the
* JavaScript code in this page
*
* Copyright 2022 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 _annotation = require("../../core/annotation.js");
var _util = require("../../shared/util.js");
var _test_utils = require("./test_utils.js");
var _api = require("../../display/api.js");
var _primitives = require("../../core/primitives.js");
var _parser = require("../../core/parser.js");
var _evaluator = require("../../core/evaluator.js");
var _stream = require("../../core/stream.js");
var _worker = require("../../core/worker.js");
describe("annotation", function () {
class PDFManagerMock {
constructor(params) {
this.docBaseUrl = params.docBaseUrl || null;
this.pdfDocument = {
catalog: {
acroForm: new _primitives.Dict()
}
};
this.evaluatorOptions = {
isOffscreenCanvasSupported: false
};
}
ensure(obj, prop, args) {
return new Promise(function (resolve) {
const value = obj[prop];
if (typeof value === "function") {
resolve(value.apply(obj, args));
} else {
resolve(value);
}
});
}
ensureCatalog(prop, args) {
return this.ensure(this.pdfDocument.catalog, prop, args);
}
ensureDoc(prop, args) {
return this.ensure(this.pdfDocument, prop, args);
}
}
const fontDataReader = new _api.DefaultStandardFontDataFactory({
baseUrl: _test_utils.STANDARD_FONT_DATA_URL
});
function HandlerMock() {
this.inputs = [];
}
HandlerMock.prototype = {
send(name, data) {
this.inputs.push({
name,
data
});
},
sendWithPromise(name, data) {
if (name !== "FetchStandardFontData") {
return Promise.reject(new Error(`Unsupported mock ${name}.`));
}
return fontDataReader.fetch(data);
}
};
let pdfManagerMock, idFactoryMock, partialEvaluator;
beforeAll(async function () {
pdfManagerMock = new PDFManagerMock({
docBaseUrl: null
});
const CMapReaderFactory = new _api.DefaultCMapReaderFactory({
baseUrl: _test_utils.CMAP_PARAMS.cMapUrl,
isCompressed: _test_utils.CMAP_PARAMS.cMapPacked
});
const builtInCMapCache = new Map();
builtInCMapCache.set("UniJIS-UTF16-H", await CMapReaderFactory.fetch({
name: "UniJIS-UTF16-H"
}));
builtInCMapCache.set("Adobe-Japan1-UCS2", await CMapReaderFactory.fetch({
name: "Adobe-Japan1-UCS2"
}));
idFactoryMock = (0, _test_utils.createIdFactory)(0);
partialEvaluator = new _evaluator.PartialEvaluator({
xref: new _test_utils.XRefMock(),
handler: new HandlerMock(),
pageIndex: 0,
idFactory: (0, _test_utils.createIdFactory)(0),
fontCache: new _primitives.RefSetCache(),
builtInCMapCache,
standardFontDataCache: new Map()
});
});
afterAll(function () {
pdfManagerMock = null;
idFactoryMock = null;
partialEvaluator = null;
});
describe("AnnotationFactory", function () {
it("should get id for annotation", async function () {
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
const annotationRef = _primitives.Ref.get(10, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.AnnotationType.LINK);
expect(data.id).toEqual("10R");
});
it("should handle, and get fallback IDs for, annotations that are not " + "indirect objects (issue 7569)", async function () {
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
const xref = new _test_utils.XRefMock();
const idFactory = (0, _test_utils.createIdFactory)(0);
const annotation1 = _annotation.AnnotationFactory.create(xref, annotationDict, pdfManagerMock, idFactory).then(({
data
}) => {
expect(data.annotationType).toEqual(_util.AnnotationType.LINK);
expect(data.id).toEqual("annot_p0_1");
});
const annotation2 = _annotation.AnnotationFactory.create(xref, annotationDict, pdfManagerMock, idFactory).then(({
data
}) => {
expect(data.annotationType).toEqual(_util.AnnotationType.LINK);
expect(data.id).toEqual("annot_p0_2");
});
await Promise.all([annotation1, annotation2]);
});
it("should handle missing /Subtype", async function () {
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
const annotationRef = _primitives.Ref.get(1, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toBeUndefined();
});
});
describe("getQuadPoints", function () {
let dict, rect;
beforeEach(function () {
dict = new _primitives.Dict();
rect = [];
});
afterEach(function () {
dict = null;
rect = null;
});
it("should ignore missing quadpoints", function () {
expect((0, _annotation.getQuadPoints)(dict, rect)).toEqual(null);
});
it("should ignore non-array values", function () {
dict.set("QuadPoints", "foo");
expect((0, _annotation.getQuadPoints)(dict, rect)).toEqual(null);
});
it("should ignore arrays where the length is not a multiple of eight", function () {
dict.set("QuadPoints", [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
expect((0, _annotation.getQuadPoints)(dict, rect)).toEqual(null);
});
it("should ignore quadpoints if one coordinate lies outside the rectangle", function () {
rect = [10, 10, 20, 20];
const inputs = [[11, 11, 12, 12, 9, 13, 14, 14], [11, 11, 12, 12, 13, 9, 14, 14], [11, 11, 12, 12, 21, 13, 14, 14], [11, 11, 12, 12, 13, 21, 14, 14]];
for (const input of inputs) {
dict.set("QuadPoints", input);
expect((0, _annotation.getQuadPoints)(dict, rect)).toEqual(null);
}
});
it("should process quadpoints in the standard order", function () {
rect = [10, 10, 20, 20];
dict.set("QuadPoints", [10, 20, 20, 20, 10, 10, 20, 10, 11, 19, 19, 19, 11, 11, 19, 11]);
expect((0, _annotation.getQuadPoints)(dict, rect)).toEqual([[{
x: 10,
y: 20
}, {
x: 20,
y: 20
}, {
x: 10,
y: 10
}, {
x: 20,
y: 10
}], [{
x: 11,
y: 19
}, {
x: 19,
y: 19
}, {
x: 11,
y: 11
}, {
x: 19,
y: 11
}]]);
});
it("should normalize and process quadpoints in non-standard orders", function () {
rect = [10, 10, 20, 20];
const nonStandardOrders = [[10, 20, 20, 20, 20, 10, 10, 10], [10, 10, 20, 10, 10, 20, 20, 20], [10, 10, 20, 10, 20, 20, 10, 20]];
for (const nonStandardOrder of nonStandardOrders) {
dict.set("QuadPoints", nonStandardOrder);
expect((0, _annotation.getQuadPoints)(dict, rect)).toEqual([[{
x: 10,
y: 20
}, {
x: 20,
y: 20
}, {
x: 10,
y: 10
}, {
x: 20,
y: 10
}]]);
}
});
});
describe("Annotation", function () {
let dict, ref;
beforeAll(function () {
dict = new _primitives.Dict();
ref = _primitives.Ref.get(1, 0);
});
afterAll(function () {
dict = ref = null;
});
it("should set and get valid contents", function () {
const annotation = new _annotation.Annotation({
dict,
ref
});
annotation.setContents("Foo bar baz");
expect(annotation._contents).toEqual({
str: "Foo bar baz",
dir: "ltr"
});
});
it("should not set and get invalid contents", function () {
const annotation = new _annotation.Annotation({
dict,
ref
});
annotation.setContents(undefined);
expect(annotation._contents).toEqual({
str: "",
dir: "ltr"
});
});
it("should set and get a valid modification date", function () {
const annotation = new _annotation.Annotation({
dict,
ref
});
annotation.setModificationDate("D:20190422");
expect(annotation.modificationDate).toEqual("D:20190422");
});
it("should not set and get an invalid modification date", function () {
const annotation = new _annotation.Annotation({
dict,
ref
});
annotation.setModificationDate(undefined);
expect(annotation.modificationDate).toEqual(null);
});
it("should set and get flags", function () {
const annotation = new _annotation.Annotation({
dict,
ref
});
annotation.setFlags(13);
expect(annotation.hasFlag(_util.AnnotationFlag.INVISIBLE)).toEqual(true);
expect(annotation.hasFlag(_util.AnnotationFlag.NOZOOM)).toEqual(true);
expect(annotation.hasFlag(_util.AnnotationFlag.PRINT)).toEqual(true);
expect(annotation.hasFlag(_util.AnnotationFlag.READONLY)).toEqual(false);
expect(annotation.hasFlag(_util.AnnotationFlag.HIDDEN)).toEqual(false);
});
it("should be viewable and not printable by default", function () {
const annotation = new _annotation.Annotation({
dict,
ref
});
expect(annotation.viewable).toEqual(true);
expect(annotation.printable).toEqual(false);
});
it("should set and get a valid rectangle", function () {
const annotation = new _annotation.Annotation({
dict,
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 () {
const annotation = new _annotation.Annotation({
dict,
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 () {
const annotation = new _annotation.Annotation({
dict,
ref
});
annotation.setColor("red");
expect(annotation.color).toEqual(new Uint8ClampedArray([0, 0, 0]));
});
it("should set and get a transparent color", function () {
const annotation = new _annotation.Annotation({
dict,
ref
});
annotation.setColor([]);
expect(annotation.color).toEqual(null);
});
it("should set and get a grayscale color", function () {
const annotation = new _annotation.Annotation({
dict,
ref
});
annotation.setColor([0.4]);
expect(annotation.color).toEqual(new Uint8ClampedArray([102, 102, 102]));
});
it("should set and get an RGB color", function () {
const annotation = new _annotation.Annotation({
dict,
ref
});
annotation.setColor([0, 0, 1]);
expect(annotation.color).toEqual(new Uint8ClampedArray([0, 0, 255]));
});
it("should set and get a CMYK color", function () {
const annotation = new _annotation.Annotation({
dict,
ref
});
annotation.setColor([0.1, 0.92, 0.84, 0.02]);
expect(annotation.color).toEqual(new Uint8ClampedArray([234, 59, 48]));
});
it("should not set and get an invalid color", function () {
const annotation = new _annotation.Annotation({
dict,
ref
});
annotation.setColor([0.4, 0.6]);
expect(annotation.color).toEqual(new Uint8ClampedArray([0, 0, 0]));
});
});
describe("AnnotationBorderStyle", function () {
it("should set and get a valid width", function () {
const borderStyleInt = new _annotation.AnnotationBorderStyle();
borderStyleInt.setWidth(3);
const borderStyleNum = new _annotation.AnnotationBorderStyle();
borderStyleNum.setWidth(2.5);
expect(borderStyleInt.width).toEqual(3);
expect(borderStyleNum.width).toEqual(2.5);
});
it("should not set and get an invalid width", function () {
const borderStyle = new _annotation.AnnotationBorderStyle();
borderStyle.setWidth("three");
expect(borderStyle.width).toEqual(1);
});
it("should set the width to zero, when the input is a `Name` (issue 10385)", function () {
const borderStyleZero = new _annotation.AnnotationBorderStyle();
borderStyleZero.setWidth(_primitives.Name.get("0"));
const borderStyleFive = new _annotation.AnnotationBorderStyle();
borderStyleFive.setWidth(_primitives.Name.get("5"));
expect(borderStyleZero.width).toEqual(0);
expect(borderStyleFive.width).toEqual(0);
});
it("should set and get a valid style", function () {
const borderStyle = new _annotation.AnnotationBorderStyle();
borderStyle.setStyle(_primitives.Name.get("D"));
expect(borderStyle.style).toEqual(_util.AnnotationBorderStyleType.DASHED);
});
it("should not set and get an invalid style", function () {
const borderStyle = new _annotation.AnnotationBorderStyle();
borderStyle.setStyle("Dashed");
expect(borderStyle.style).toEqual(_util.AnnotationBorderStyleType.SOLID);
});
it("should set and get a valid dash array", function () {
const borderStyle = new _annotation.AnnotationBorderStyle();
borderStyle.setDashArray([1, 2, 3]);
expect(borderStyle.dashArray).toEqual([1, 2, 3]);
});
it("should not set and get an invalid dash array", function () {
const borderStyle = new _annotation.AnnotationBorderStyle();
borderStyle.setDashArray([0, 0]);
expect(borderStyle.dashArray).toEqual([3]);
});
it("should set and get a valid horizontal corner radius", function () {
const borderStyle = new _annotation.AnnotationBorderStyle();
borderStyle.setHorizontalCornerRadius(3);
expect(borderStyle.horizontalCornerRadius).toEqual(3);
});
it("should not set and get an invalid horizontal corner radius", function () {
const borderStyle = new _annotation.AnnotationBorderStyle();
borderStyle.setHorizontalCornerRadius("three");
expect(borderStyle.horizontalCornerRadius).toEqual(0);
});
it("should set and get a valid vertical corner radius", function () {
const borderStyle = new _annotation.AnnotationBorderStyle();
borderStyle.setVerticalCornerRadius(3);
expect(borderStyle.verticalCornerRadius).toEqual(3);
});
it("should not set and get an invalid vertical corner radius", function () {
const borderStyle = new _annotation.AnnotationBorderStyle();
borderStyle.setVerticalCornerRadius("three");
expect(borderStyle.verticalCornerRadius).toEqual(0);
});
});
describe("MarkupAnnotation", function () {
let dict, ref;
beforeAll(function () {
dict = new _primitives.Dict();
ref = _primitives.Ref.get(1, 0);
});
afterAll(function () {
dict = ref = null;
});
it("should set and get a valid creation date", function () {
const markupAnnotation = new _annotation.MarkupAnnotation({
dict,
ref
});
markupAnnotation.setCreationDate("D:20190422");
expect(markupAnnotation.creationDate).toEqual("D:20190422");
});
it("should not set and get an invalid creation date", function () {
const markupAnnotation = new _annotation.MarkupAnnotation({
dict,
ref
});
markupAnnotation.setCreationDate(undefined);
expect(markupAnnotation.creationDate).toEqual(null);
});
it("should not parse IRT/RT when not defined", async function () {
dict.set("Type", _primitives.Name.get("Annot"));
dict.set("Subtype", _primitives.Name.get("Text"));
const xref = new _test_utils.XRefMock([{
ref,
data: dict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, ref, pdfManagerMock, idFactoryMock);
expect(data.inReplyTo).toBeUndefined();
expect(data.replyType).toBeUndefined();
});
it("should parse IRT and set default RT when not defined", async function () {
const annotationRef = _primitives.Ref.get(819, 0);
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Text"));
const replyRef = _primitives.Ref.get(820, 0);
const replyDict = new _primitives.Dict();
replyDict.set("Type", _primitives.Name.get("Annot"));
replyDict.set("Subtype", _primitives.Name.get("Text"));
replyDict.set("IRT", annotationRef);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}, {
ref: replyRef,
data: replyDict
}]);
annotationDict.assignXref(xref);
replyDict.assignXref(xref);
const {
data
} = await _annotation.AnnotationFactory.create(xref, replyRef, pdfManagerMock, idFactoryMock);
expect(data.inReplyTo).toEqual(annotationRef.toString());
expect(data.replyType).toEqual("R");
});
it("should parse IRT/RT for a group type", async function () {
const annotationRef = _primitives.Ref.get(819, 0);
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Text"));
annotationDict.set("T", "ParentTitle");
annotationDict.set("Contents", "ParentText");
annotationDict.set("CreationDate", "D:20180423");
annotationDict.set("M", "D:20190423");
annotationDict.set("C", [0, 0, 1]);
const popupRef = _primitives.Ref.get(820, 0);
const popupDict = new _primitives.Dict();
popupDict.set("Type", _primitives.Name.get("Annot"));
popupDict.set("Subtype", _primitives.Name.get("Popup"));
popupDict.set("Parent", annotationRef);
annotationDict.set("Popup", popupRef);
const replyRef = _primitives.Ref.get(821, 0);
const replyDict = new _primitives.Dict();
replyDict.set("Type", _primitives.Name.get("Annot"));
replyDict.set("Subtype", _primitives.Name.get("Text"));
replyDict.set("IRT", annotationRef);
replyDict.set("RT", _primitives.Name.get("Group"));
replyDict.set("T", "ReplyTitle");
replyDict.set("Contents", "ReplyText");
replyDict.set("CreationDate", "D:20180523");
replyDict.set("M", "D:20190523");
replyDict.set("C", [0.4]);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}, {
ref: popupRef,
data: popupDict
}, {
ref: replyRef,
data: replyDict
}]);
annotationDict.assignXref(xref);
popupDict.assignXref(xref);
replyDict.assignXref(xref);
const {
data
} = await _annotation.AnnotationFactory.create(xref, replyRef, pdfManagerMock, idFactoryMock);
expect(data.inReplyTo).toEqual(annotationRef.toString());
expect(data.replyType).toEqual("Group");
expect(data.titleObj).toEqual({
str: "ParentTitle",
dir: "ltr"
});
expect(data.contentsObj).toEqual({
str: "ParentText",
dir: "ltr"
});
expect(data.creationDate).toEqual("D:20180423");
expect(data.modificationDate).toEqual("D:20190423");
expect(data.color).toEqual(new Uint8ClampedArray([0, 0, 255]));
expect(data.hasPopup).toEqual(true);
});
it("should parse IRT/RT for a reply type", async function () {
const annotationRef = _primitives.Ref.get(819, 0);
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Text"));
annotationDict.set("T", "ParentTitle");
annotationDict.set("Contents", "ParentText");
annotationDict.set("CreationDate", "D:20180423");
annotationDict.set("M", "D:20190423");
annotationDict.set("C", [0, 0, 1]);
const popupRef = _primitives.Ref.get(820, 0);
const popupDict = new _primitives.Dict();
popupDict.set("Type", _primitives.Name.get("Annot"));
popupDict.set("Subtype", _primitives.Name.get("Popup"));
popupDict.set("Parent", annotationRef);
annotationDict.set("Popup", popupRef);
const replyRef = _primitives.Ref.get(821, 0);
const replyDict = new _primitives.Dict();
replyDict.set("Type", _primitives.Name.get("Annot"));
replyDict.set("Subtype", _primitives.Name.get("Text"));
replyDict.set("IRT", annotationRef);
replyDict.set("RT", _primitives.Name.get("R"));
replyDict.set("T", "ReplyTitle");
replyDict.set("Contents", "ReplyText");
replyDict.set("CreationDate", "D:20180523");
replyDict.set("M", "D:20190523");
replyDict.set("C", [0.4]);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}, {
ref: popupRef,
data: popupDict
}, {
ref: replyRef,
data: replyDict
}]);
annotationDict.assignXref(xref);
popupDict.assignXref(xref);
replyDict.assignXref(xref);
const {
data
} = await _annotation.AnnotationFactory.create(xref, replyRef, pdfManagerMock, idFactoryMock);
expect(data.inReplyTo).toEqual(annotationRef.toString());
expect(data.replyType).toEqual("R");
expect(data.titleObj).toEqual({
str: "ReplyTitle",
dir: "ltr"
});
expect(data.contentsObj).toEqual({
str: "ReplyText",
dir: "ltr"
});
expect(data.creationDate).toEqual("D:20180523");
expect(data.modificationDate).toEqual("D:20190523");
expect(data.color).toEqual(new Uint8ClampedArray([102, 102, 102]));
expect(data.hasPopup).toEqual(false);
});
});
describe("TextAnnotation", function () {
it("should not parse state model and state when not defined", async function () {
const annotationRef = _primitives.Ref.get(819, 0);
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Text"));
annotationDict.set("Contents", "TestText");
const replyRef = _primitives.Ref.get(820, 0);
const replyDict = new _primitives.Dict();
replyDict.set("Type", _primitives.Name.get("Annot"));
replyDict.set("Subtype", _primitives.Name.get("Text"));
replyDict.set("IRT", annotationRef);
replyDict.set("RT", _primitives.Name.get("R"));
replyDict.set("Contents", "ReplyText");
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}, {
ref: replyRef,
data: replyDict
}]);
annotationDict.assignXref(xref);
replyDict.assignXref(xref);
const {
data
} = await _annotation.AnnotationFactory.create(xref, replyRef, pdfManagerMock, idFactoryMock);
expect(data.stateModel).toBeNull();
expect(data.state).toBeNull();
});
it("should correctly parse state model and state when defined", async function () {
const annotationRef = _primitives.Ref.get(819, 0);
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Text"));
const replyRef = _primitives.Ref.get(820, 0);
const replyDict = new _primitives.Dict();
replyDict.set("Type", _primitives.Name.get("Annot"));
replyDict.set("Subtype", _primitives.Name.get("Text"));
replyDict.set("IRT", annotationRef);
replyDict.set("RT", _primitives.Name.get("R"));
replyDict.set("StateModel", "Review");
replyDict.set("State", "Rejected");
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}, {
ref: replyRef,
data: replyDict
}]);
annotationDict.assignXref(xref);
replyDict.assignXref(xref);
const {
data
} = await _annotation.AnnotationFactory.create(xref, replyRef, pdfManagerMock, idFactoryMock);
expect(data.stateModel).toEqual("Review");
expect(data.state).toEqual("Rejected");
});
});
describe("LinkAnnotation", function () {
it("should correctly parse a URI action", async function () {
const actionDict = new _primitives.Dict();
actionDict.set("Type", _primitives.Name.get("Action"));
actionDict.set("S", _primitives.Name.get("URI"));
actionDict.set("URI", "http://www.ctan.org/tex-archive/info/lshort");
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
annotationDict.set("A", actionDict);
const annotationRef = _primitives.Ref.get(820, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.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", async function () {
const actionDict = new _primitives.Dict();
actionDict.set("Type", _primitives.Name.get("Action"));
actionDict.set("S", _primitives.Name.get("URI"));
actionDict.set("URI", "www.hmrc.gov.uk");
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
annotationDict.set("A", actionDict);
const annotationRef = _primitives.Ref.get(353, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.AnnotationType.LINK);
expect(data.url).toEqual("http://www.hmrc.gov.uk/");
expect(data.unsafeUrl).toEqual("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)", async function () {
const actionStream = new _stream.StringStream("<<\n" + "/Type /Action\n" + "/S /URI\n" + "/URI (http://www.example.com/\\303\\274\\303\\266\\303\\244)\n" + ">>\n");
const parser = new _parser.Parser({
lexer: new _parser.Lexer(actionStream),
xref: null
});
const actionDict = parser.getObj();
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
annotationDict.set("A", actionDict);
const annotationRef = _primitives.Ref.get(8, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.AnnotationType.LINK);
expect(data.url).toEqual(new URL((0, _util.stringToUTF8String)("http://www.example.com/\xC3\xBC\xC3\xB6\xC3\xA4")).href);
expect(data.unsafeUrl).toEqual("http://www.example.com/\xC3\xBC\xC3\xB6\xC3\xA4");
expect(data.dest).toBeUndefined();
});
it("should correctly parse a GoTo action", async function () {
const actionDict = new _primitives.Dict();
actionDict.set("Type", _primitives.Name.get("Action"));
actionDict.set("S", _primitives.Name.get("GoTo"));
actionDict.set("D", "page.157");
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
annotationDict.set("A", actionDict);
const annotationRef = _primitives.Ref.get(798, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.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", async function () {
const actionDict = new _primitives.Dict();
actionDict.set("Type", _primitives.Name.get("Action"));
actionDict.set("S", _primitives.Name.get("GoToR"));
actionDict.set("F", "../../0013/001346/134685E.pdf");
actionDict.set("D", "4.3");
actionDict.set("NewWindow", true);
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
annotationDict.set("A", actionDict);
const annotationRef = _primitives.Ref.get(489, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.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', async function () {
const actionDict = new _primitives.Dict();
actionDict.set("Type", _primitives.Name.get("Action"));
actionDict.set("S", _primitives.Name.get("GoToR"));
actionDict.set("F", "../../0013/001346/134685E.pdf");
actionDict.set("D", "4.3");
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
annotationDict.set("A", actionDict);
const annotationRef = _primitives.Ref.get(489, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
const pdfManager = new PDFManagerMock({
docBaseUrl: "http://www.example.com/test/pdfs/qwerty.pdf"
});
const {
data
} = await _annotation.AnnotationFactory.create(xref, annotationRef, pdfManager, idFactoryMock);
expect(data.annotationType).toEqual(_util.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", async function () {
const actionDict = new _primitives.Dict();
actionDict.set("Type", _primitives.Name.get("Action"));
actionDict.set("S", _primitives.Name.get("GoToR"));
actionDict.set("F", "http://www.example.com/test.pdf");
actionDict.set("D", "15");
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
annotationDict.set("A", actionDict);
const annotationRef = _primitives.Ref.get(495, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.AnnotationType.LINK);
expect(data.url).toEqual("http://www.example.com/test.pdf#15");
expect(data.unsafeUrl).toEqual("http://www.example.com/test.pdf#15");
expect(data.dest).toBeUndefined();
expect(data.newWindow).toBeFalsy();
});
it("should correctly parse a GoToR action, with explicit destination array", async function () {
const actionDict = new _primitives.Dict();
actionDict.set("Type", _primitives.Name.get("Action"));
actionDict.set("S", _primitives.Name.get("GoToR"));
actionDict.set("F", "http://www.example.com/test.pdf");
actionDict.set("D", [14, _primitives.Name.get("XYZ"), null, 298.043, null]);
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
annotationDict.set("A", actionDict);
const annotationRef = _primitives.Ref.get(489, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.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', async function () {
const fileSpecDict = new _primitives.Dict();
fileSpecDict.set("Type", _primitives.Name.get("FileSpec"));
fileSpecDict.set("F", "Part II/Part II.pdf");
fileSpecDict.set("UF", "Part II/Part II.pdf");
const actionDict = new _primitives.Dict();
actionDict.set("Type", _primitives.Name.get("Action"));
actionDict.set("S", _primitives.Name.get("Launch"));
actionDict.set("F", fileSpecDict);
actionDict.set("NewWindow", true);
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
annotationDict.set("A", actionDict);
const annotationRef = _primitives.Ref.get(88, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
const pdfManager = new PDFManagerMock({
docBaseUrl: "http://www.example.com/test/pdfs/qwerty.pdf"
});
const {
data
} = await _annotation.AnnotationFactory.create(xref, annotationRef, pdfManager, idFactoryMock);
expect(data.annotationType).toEqual(_util.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", async function () {
function checkJsAction(params) {
const jsEntry = params.jsEntry;
const expectedUrl = params.expectedUrl;
const expectedUnsafeUrl = params.expectedUnsafeUrl;
const expectedNewWindow = params.expectedNewWindow;
const actionDict = new _primitives.Dict();
actionDict.set("Type", _primitives.Name.get("Action"));
actionDict.set("S", _primitives.Name.get("JavaScript"));
actionDict.set("JS", jsEntry);
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
annotationDict.set("A", actionDict);
const annotationRef = _primitives.Ref.get(46, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
return _annotation.AnnotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock).then(({
data
}) => {
expect(data.annotationType).toEqual(_util.AnnotationType.LINK);
expect(data.url).toEqual(expectedUrl);
expect(data.unsafeUrl).toEqual(expectedUnsafeUrl);
expect(data.dest).toBeUndefined();
expect(data.newWindow).toEqual(expectedNewWindow);
});
}
const annotation1 = checkJsAction({
jsEntry: 'function someFun() { return "qwerty"; } someFun();',
expectedUrl: undefined,
expectedUnsafeUrl: undefined,
expectedNewWindow: undefined
});
const annotation2 = 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: false
});
const annotation3 = checkJsAction({
jsEntry: new _stream.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
});
await Promise.all([annotation1, annotation2, annotation3]);
});
it("should correctly parse a Named action", async function () {
const actionDict = new _primitives.Dict();
actionDict.set("Type", _primitives.Name.get("Action"));
actionDict.set("S", _primitives.Name.get("Named"));
actionDict.set("N", _primitives.Name.get("GoToPage"));
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
annotationDict.set("A", actionDict);
const annotationRef = _primitives.Ref.get(12, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.AnnotationType.LINK);
expect(data.url).toBeUndefined();
expect(data.unsafeUrl).toBeUndefined();
expect(data.action).toEqual("GoToPage");
});
it("should correctly parse a simple Dest", async function () {
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
annotationDict.set("Dest", _primitives.Name.get("LI0"));
const annotationRef = _primitives.Ref.get(583, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.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", async function () {
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
annotationDict.set("Dest", [_primitives.Ref.get(17, 0), _primitives.Name.get("XYZ"), 0, 841.89, null]);
const annotationRef = _primitives.Ref.get(10, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.AnnotationType.LINK);
expect(data.url).toBeUndefined();
expect(data.unsafeUrl).toBeUndefined();
expect(data.dest).toEqual([_primitives.Ref.get(17, 0), _primitives.Name.get("XYZ"), 0, 841.89, null]);
});
it("should correctly parse a Dest, which violates the specification " + "by containing a dictionary", async function () {
const destDict = new _primitives.Dict();
destDict.set("Type", _primitives.Name.get("Action"));
destDict.set("S", _primitives.Name.get("GoTo"));
destDict.set("D", "page.157");
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
annotationDict.set("Dest", destDict);
const annotationRef = _primitives.Ref.get(798, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.AnnotationType.LINK);
expect(data.url).toBeUndefined();
expect(data.unsafeUrl).toBeUndefined();
expect(data.dest).toEqual("page.157");
});
it("should not set quadpoints if not defined", async function () {
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
const annotationRef = _primitives.Ref.get(121, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.AnnotationType.LINK);
expect(data.quadPoints).toBeUndefined();
});
it("should set quadpoints if defined", async function () {
const annotationDict = new _primitives.Dict();
annotationDict.set("Type", _primitives.Name.get("Annot"));
annotationDict.set("Subtype", _primitives.Name.get("Link"));
annotationDict.set("Rect", [10, 10, 20, 20]);
annotationDict.set("QuadPoints", [10, 20, 20, 20, 10, 10, 20, 10]);
const annotationRef = _primitives.Ref.get(121, 0);
const xref = new _test_utils.XRefMock([{
ref: annotationRef,
data: annotationDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, annotationRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.AnnotationType.LINK);
expect(data.quadPoints).toEqual([[{
x: 10,
y: 20
}, {
x: 20,
y: 20
}, {
x: 10,
y: 10
}, {
x: 20,
y: 10
}]]);
});
});
describe("WidgetAnnotation", function () {
let widgetDict;
beforeEach(function () {
widgetDict = new _primitives.Dict();
widgetDict.set("Type", _primitives.Name.get("Annot"));
widgetDict.set("Subtype", _primitives.Name.get("Widget"));
});
afterEach(function () {
widgetDict = null;
});
it("should handle unknown field names", async function () {
const widgetRef = _primitives.Ref.get(20, 0);
const xref = new _test_utils.XRefMock([{
ref: widgetRef,
data: widgetDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, widgetRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.AnnotationType.WIDGET);
expect(data.fieldName).toEqual("");
});
it("should construct the field name when there are no ancestors", async function () {
widgetDict.set("T", "foo");
const widgetRef = _primitives.Ref.get(21, 0);
const xref = new _test_utils.XRefMock([{
ref: widgetRef,
data: widgetDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, widgetRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.AnnotationType.WIDGET);
expect(data.fieldName).toEqual("foo");
});
it("should construct the field name when there are ancestors", async function () {
const firstParent = new _primitives.Dict();
firstParent.set("T", "foo");
const secondParent = new _primitives.Dict();
secondParent.set("Parent", firstParent);
secondParent.set("T", "bar");
widgetDict.set("Parent", secondParent);
widgetDict.set("T", "baz");
const widgetRef = _primitives.Ref.get(22, 0);
const xref = new _test_utils.XRefMock([{
ref: widgetRef,
data: widgetDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, widgetRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.AnnotationType.WIDGET);
expect(data.fieldName).toEqual("foo.bar.baz");
});
it("should construct the field name if a parent is not a dictionary " + "(issue 8143)", async function () {
const parentDict = new _primitives.Dict();
parentDict.set("Parent", null);
parentDict.set("T", "foo");
widgetDict.set("Parent", parentDict);
widgetDict.set("T", "bar");
const widgetRef = _primitives.Ref.get(22, 0);
const xref = new _test_utils.XRefMock([{
ref: widgetRef,
data: widgetDict
}]);
const {
data
} = await _annotation.AnnotationFactory.create(xref, widgetRef, pdfManagerMock, idFactoryMock);
expect(data.annotationType).toEqual(_util.AnnotationType.WIDGET);
expect(data.fieldName).toEqual("foo.bar");
});
});
describe("TextWidgetAnnotation", function () {
let textWidgetDict, helvRefObj, gothRefObj;
beforeEach(function () {
textWidgetDict = new _primitives.Dict();
textWidgetDict.set("Type", _primitives.Name.get("Annot"));
textWidgetDict.set("Subtype", _primitives.Name.get("Widget"));
textWidgetDict.set("FT", _primitives.Name.get("Tx"));
const helvDict = new _primitives.Dict();
helvDict.set("BaseFont", _primitives.Name.get("Helvetica"));
helvDict.set("Type", _primitives.Name.get("Font"));
helvDict.set("Subtype", _primitives.Name.get("Type1"));
const gothDict = new _primitives.Dict();
gothDict.set("BaseFont", _primitives.Name.get("MSGothic"));
gothDict.set("Type", _primitives.Name.get("Font"));
gothDict.set("Subtype", _primitives.Name.get("Type0"));
gothDict.set("Encoding", _primitives.Name.get("UniJIS-UTF16-H"));
gothDict.set("Name", _primitives.Name.get("MSGothic"));
const cidSysInfoDict = new _primitives.Dict();
cidSysInfoDict.set("Ordering", "Japan1");
cidSysInfoDict.set("Registry", "Adobe");
cidSysInfoDict.set("Supplement", "5");
const fontDescriptorDict = new _primitives.Dict();
fontDescriptorDict.set("FontName", _primitives.Name.get("MSGothic"));
fontDescriptorDict.set("CapHeight", "680");
const gothDescendantDict = new _primitives.Dict();
gothDescendantDict.set("BaseFont", _primitives.Name.get("MSGothic"));
gothDescendantDict.set("CIDSystemInfo", cidSysInfoDict);
gothDescendantDict.set("Subtype", _primitives.Name.get("CIDFontType2"));
gothDescendantDict.set("Type", _primitives.Name.get("Font"));
gothDescendantDict.set("FontDescriptor", fontDescriptorDict);
gothDict.set("DescendantFonts", [gothDescendantDict]);
const helvRef = _primitives.Ref.get(314, 0);
const gothRef = _primitives.Ref.get(159, 0);
helvRefObj = {
ref: helvRef,
data: helvDict
};
gothRefObj = {
ref: gothRef,
data: gothDict
};
const resourceDict = new _primitives.Dict();
const fontDict = new _primitives.Dict();
fontDict.set("Helv", he