2494 lines
64 KiB
JavaScript
2494 lines
64 KiB
JavaScript
/**
|
|
* @licstart The following is the entire license notice for the
|
|
* Javascript code in this page
|
|
*
|
|
* Copyright 2020 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";
|
|
|
|
Object.defineProperty(exports, "__esModule", {
|
|
value: true
|
|
});
|
|
exports.FileSpec = exports.XRef = exports.ObjectLoader = exports.Catalog = void 0;
|
|
|
|
var _util = require("../shared/util.js");
|
|
|
|
var _primitives = require("./primitives.js");
|
|
|
|
var _parser = require("./parser.js");
|
|
|
|
var _core_utils = require("./core_utils.js");
|
|
|
|
var _crypto = require("./crypto.js");
|
|
|
|
var _colorspace = require("./colorspace.js");
|
|
|
|
var _image_utils = require("./image_utils.js");
|
|
|
|
function fetchDestination(dest) {
|
|
return (0, _primitives.isDict)(dest) ? dest.get("D") : dest;
|
|
}
|
|
|
|
class Catalog {
|
|
constructor(pdfManager, xref) {
|
|
this.pdfManager = pdfManager;
|
|
this.xref = xref;
|
|
this._catDict = xref.getCatalogObj();
|
|
|
|
if (!(0, _primitives.isDict)(this._catDict)) {
|
|
throw new _util.FormatError("Catalog object is not a dictionary.");
|
|
}
|
|
|
|
this.fontCache = new _primitives.RefSetCache();
|
|
this.builtInCMapCache = new Map();
|
|
this.globalImageCache = new _image_utils.GlobalImageCache();
|
|
this.pageKidsCountCache = new _primitives.RefSetCache();
|
|
}
|
|
|
|
get version() {
|
|
const version = this._catDict.get("Version");
|
|
|
|
if (!(0, _primitives.isName)(version)) {
|
|
return (0, _util.shadow)(this, "version", null);
|
|
}
|
|
|
|
return (0, _util.shadow)(this, "version", version.name);
|
|
}
|
|
|
|
get collection() {
|
|
let collection = null;
|
|
|
|
try {
|
|
const obj = this._catDict.get("Collection");
|
|
|
|
if ((0, _primitives.isDict)(obj) && obj.size > 0) {
|
|
collection = obj;
|
|
}
|
|
} catch (ex) {
|
|
if (ex instanceof _core_utils.MissingDataException) {
|
|
throw ex;
|
|
}
|
|
|
|
(0, _util.info)("Cannot fetch Collection entry; assuming no collection is present.");
|
|
}
|
|
|
|
return (0, _util.shadow)(this, "collection", collection);
|
|
}
|
|
|
|
get acroForm() {
|
|
let acroForm = null;
|
|
|
|
try {
|
|
const obj = this._catDict.get("AcroForm");
|
|
|
|
if ((0, _primitives.isDict)(obj) && obj.size > 0) {
|
|
acroForm = obj;
|
|
}
|
|
} catch (ex) {
|
|
if (ex instanceof _core_utils.MissingDataException) {
|
|
throw ex;
|
|
}
|
|
|
|
(0, _util.info)("Cannot fetch AcroForm entry; assuming no forms are present.");
|
|
}
|
|
|
|
return (0, _util.shadow)(this, "acroForm", acroForm);
|
|
}
|
|
|
|
get metadata() {
|
|
const streamRef = this._catDict.getRaw("Metadata");
|
|
|
|
if (!(0, _primitives.isRef)(streamRef)) {
|
|
return (0, _util.shadow)(this, "metadata", null);
|
|
}
|
|
|
|
const suppressEncryption = !(this.xref.encrypt && this.xref.encrypt.encryptMetadata);
|
|
const stream = this.xref.fetch(streamRef, suppressEncryption);
|
|
let metadata;
|
|
|
|
if (stream && (0, _primitives.isDict)(stream.dict)) {
|
|
const type = stream.dict.get("Type");
|
|
const subtype = stream.dict.get("Subtype");
|
|
|
|
if ((0, _primitives.isName)(type, "Metadata") && (0, _primitives.isName)(subtype, "XML")) {
|
|
try {
|
|
metadata = (0, _util.stringToUTF8String)((0, _util.bytesToString)(stream.getBytes()));
|
|
} catch (e) {
|
|
if (e instanceof _core_utils.MissingDataException) {
|
|
throw e;
|
|
}
|
|
|
|
(0, _util.info)("Skipping invalid metadata.");
|
|
}
|
|
}
|
|
}
|
|
|
|
return (0, _util.shadow)(this, "metadata", metadata);
|
|
}
|
|
|
|
get toplevelPagesDict() {
|
|
const pagesObj = this._catDict.get("Pages");
|
|
|
|
if (!(0, _primitives.isDict)(pagesObj)) {
|
|
throw new _util.FormatError("Invalid top-level pages dictionary.");
|
|
}
|
|
|
|
return (0, _util.shadow)(this, "toplevelPagesDict", pagesObj);
|
|
}
|
|
|
|
get documentOutline() {
|
|
let obj = null;
|
|
|
|
try {
|
|
obj = this._readDocumentOutline();
|
|
} catch (ex) {
|
|
if (ex instanceof _core_utils.MissingDataException) {
|
|
throw ex;
|
|
}
|
|
|
|
(0, _util.warn)("Unable to read document outline.");
|
|
}
|
|
|
|
return (0, _util.shadow)(this, "documentOutline", obj);
|
|
}
|
|
|
|
_readDocumentOutline() {
|
|
let obj = this._catDict.get("Outlines");
|
|
|
|
if (!(0, _primitives.isDict)(obj)) {
|
|
return null;
|
|
}
|
|
|
|
obj = obj.getRaw("First");
|
|
|
|
if (!(0, _primitives.isRef)(obj)) {
|
|
return null;
|
|
}
|
|
|
|
const root = {
|
|
items: []
|
|
};
|
|
const queue = [{
|
|
obj,
|
|
parent: root
|
|
}];
|
|
const processed = new _primitives.RefSet();
|
|
processed.put(obj);
|
|
const xref = this.xref,
|
|
blackColor = new Uint8ClampedArray(3);
|
|
|
|
while (queue.length > 0) {
|
|
const i = queue.shift();
|
|
const outlineDict = xref.fetchIfRef(i.obj);
|
|
|
|
if (outlineDict === null) {
|
|
continue;
|
|
}
|
|
|
|
if (!outlineDict.has("Title")) {
|
|
throw new _util.FormatError("Invalid outline item encountered.");
|
|
}
|
|
|
|
const data = {
|
|
url: null,
|
|
dest: null
|
|
};
|
|
Catalog.parseDestDictionary({
|
|
destDict: outlineDict,
|
|
resultObj: data,
|
|
docBaseUrl: this.pdfManager.docBaseUrl
|
|
});
|
|
const title = outlineDict.get("Title");
|
|
const flags = outlineDict.get("F") || 0;
|
|
const color = outlineDict.getArray("C");
|
|
const count = outlineDict.get("Count");
|
|
let rgbColor = blackColor;
|
|
|
|
if (Array.isArray(color) && color.length === 3 && (color[0] !== 0 || color[1] !== 0 || color[2] !== 0)) {
|
|
rgbColor = _colorspace.ColorSpace.singletons.rgb.getRgb(color, 0);
|
|
}
|
|
|
|
const outlineItem = {
|
|
dest: data.dest,
|
|
url: data.url,
|
|
unsafeUrl: data.unsafeUrl,
|
|
newWindow: data.newWindow,
|
|
title: (0, _util.stringToPDFString)(title),
|
|
color: rgbColor,
|
|
count: Number.isInteger(count) ? count : undefined,
|
|
bold: !!(flags & 2),
|
|
italic: !!(flags & 1),
|
|
items: []
|
|
};
|
|
i.parent.items.push(outlineItem);
|
|
obj = outlineDict.getRaw("First");
|
|
|
|
if ((0, _primitives.isRef)(obj) && !processed.has(obj)) {
|
|
queue.push({
|
|
obj,
|
|
parent: outlineItem
|
|
});
|
|
processed.put(obj);
|
|
}
|
|
|
|
obj = outlineDict.getRaw("Next");
|
|
|
|
if ((0, _primitives.isRef)(obj) && !processed.has(obj)) {
|
|
queue.push({
|
|
obj,
|
|
parent: i.parent
|
|
});
|
|
processed.put(obj);
|
|
}
|
|
}
|
|
|
|
return root.items.length > 0 ? root.items : null;
|
|
}
|
|
|
|
get permissions() {
|
|
let permissions = null;
|
|
|
|
try {
|
|
permissions = this._readPermissions();
|
|
} catch (ex) {
|
|
if (ex instanceof _core_utils.MissingDataException) {
|
|
throw ex;
|
|
}
|
|
|
|
(0, _util.warn)("Unable to read permissions.");
|
|
}
|
|
|
|
return (0, _util.shadow)(this, "permissions", permissions);
|
|
}
|
|
|
|
_readPermissions() {
|
|
const encrypt = this.xref.trailer.get("Encrypt");
|
|
|
|
if (!(0, _primitives.isDict)(encrypt)) {
|
|
return null;
|
|
}
|
|
|
|
let flags = encrypt.get("P");
|
|
|
|
if (!(0, _util.isNum)(flags)) {
|
|
return null;
|
|
}
|
|
|
|
flags += 2 ** 32;
|
|
const permissions = [];
|
|
|
|
for (const key in _util.PermissionFlag) {
|
|
const value = _util.PermissionFlag[key];
|
|
|
|
if (flags & value) {
|
|
permissions.push(value);
|
|
}
|
|
}
|
|
|
|
return permissions;
|
|
}
|
|
|
|
get optionalContentConfig() {
|
|
let config = null;
|
|
|
|
try {
|
|
const properties = this._catDict.get("OCProperties");
|
|
|
|
if (!properties) {
|
|
return (0, _util.shadow)(this, "optionalContentConfig", null);
|
|
}
|
|
|
|
const defaultConfig = properties.get("D");
|
|
|
|
if (!defaultConfig) {
|
|
return (0, _util.shadow)(this, "optionalContentConfig", null);
|
|
}
|
|
|
|
const groupsData = properties.get("OCGs");
|
|
|
|
if (!Array.isArray(groupsData)) {
|
|
return (0, _util.shadow)(this, "optionalContentConfig", null);
|
|
}
|
|
|
|
const groups = [];
|
|
const groupRefs = [];
|
|
|
|
for (const groupRef of groupsData) {
|
|
if (!(0, _primitives.isRef)(groupRef)) {
|
|
continue;
|
|
}
|
|
|
|
groupRefs.push(groupRef);
|
|
const group = this.xref.fetchIfRef(groupRef);
|
|
groups.push({
|
|
id: groupRef.toString(),
|
|
name: (0, _util.isString)(group.get("Name")) ? (0, _util.stringToPDFString)(group.get("Name")) : null,
|
|
intent: (0, _util.isString)(group.get("Intent")) ? (0, _util.stringToPDFString)(group.get("Intent")) : null
|
|
});
|
|
}
|
|
|
|
config = this._readOptionalContentConfig(defaultConfig, groupRefs);
|
|
config.groups = groups;
|
|
} catch (ex) {
|
|
if (ex instanceof _core_utils.MissingDataException) {
|
|
throw ex;
|
|
}
|
|
|
|
(0, _util.warn)(`Unable to read optional content config: ${ex}`);
|
|
}
|
|
|
|
return (0, _util.shadow)(this, "optionalContentConfig", config);
|
|
}
|
|
|
|
_readOptionalContentConfig(config, contentGroupRefs) {
|
|
function parseOnOff(refs) {
|
|
const onParsed = [];
|
|
|
|
if (Array.isArray(refs)) {
|
|
for (const value of refs) {
|
|
if (!(0, _primitives.isRef)(value)) {
|
|
continue;
|
|
}
|
|
|
|
if (contentGroupRefs.includes(value)) {
|
|
onParsed.push(value.toString());
|
|
}
|
|
}
|
|
}
|
|
|
|
return onParsed;
|
|
}
|
|
|
|
function parseOrder(refs, nestedLevels = 0) {
|
|
if (!Array.isArray(refs)) {
|
|
return null;
|
|
}
|
|
|
|
const order = [];
|
|
|
|
for (const value of refs) {
|
|
if ((0, _primitives.isRef)(value) && contentGroupRefs.includes(value)) {
|
|
parsedOrderRefs.put(value);
|
|
order.push(value.toString());
|
|
continue;
|
|
}
|
|
|
|
const nestedOrder = parseNestedOrder(value, nestedLevels);
|
|
|
|
if (nestedOrder) {
|
|
order.push(nestedOrder);
|
|
}
|
|
}
|
|
|
|
if (nestedLevels > 0) {
|
|
return order;
|
|
}
|
|
|
|
const hiddenGroups = [];
|
|
|
|
for (const groupRef of contentGroupRefs) {
|
|
if (parsedOrderRefs.has(groupRef)) {
|
|
continue;
|
|
}
|
|
|
|
hiddenGroups.push(groupRef.toString());
|
|
}
|
|
|
|
if (hiddenGroups.length) {
|
|
order.push({
|
|
name: null,
|
|
order: hiddenGroups
|
|
});
|
|
}
|
|
|
|
return order;
|
|
}
|
|
|
|
function parseNestedOrder(ref, nestedLevels) {
|
|
if (++nestedLevels > MAX_NESTED_LEVELS) {
|
|
(0, _util.warn)("parseNestedOrder - reached MAX_NESTED_LEVELS.");
|
|
return null;
|
|
}
|
|
|
|
const value = xref.fetchIfRef(ref);
|
|
|
|
if (!Array.isArray(value)) {
|
|
return null;
|
|
}
|
|
|
|
const nestedName = xref.fetchIfRef(value[0]);
|
|
|
|
if (typeof nestedName !== "string") {
|
|
return null;
|
|
}
|
|
|
|
const nestedOrder = parseOrder(value.slice(1), nestedLevels);
|
|
|
|
if (!nestedOrder || !nestedOrder.length) {
|
|
return null;
|
|
}
|
|
|
|
return {
|
|
name: (0, _util.stringToPDFString)(nestedName),
|
|
order: nestedOrder
|
|
};
|
|
}
|
|
|
|
const xref = this.xref,
|
|
parsedOrderRefs = new _primitives.RefSet(),
|
|
MAX_NESTED_LEVELS = 10;
|
|
return {
|
|
name: (0, _util.isString)(config.get("Name")) ? (0, _util.stringToPDFString)(config.get("Name")) : null,
|
|
creator: (0, _util.isString)(config.get("Creator")) ? (0, _util.stringToPDFString)(config.get("Creator")) : null,
|
|
baseState: (0, _primitives.isName)(config.get("BaseState")) ? config.get("BaseState").name : null,
|
|
on: parseOnOff(config.get("ON")),
|
|
off: parseOnOff(config.get("OFF")),
|
|
order: parseOrder(config.get("Order")),
|
|
groups: null
|
|
};
|
|
}
|
|
|
|
get numPages() {
|
|
const obj = this.toplevelPagesDict.get("Count");
|
|
|
|
if (!Number.isInteger(obj)) {
|
|
throw new _util.FormatError("Page count in top-level pages dictionary is not an integer.");
|
|
}
|
|
|
|
return (0, _util.shadow)(this, "numPages", obj);
|
|
}
|
|
|
|
get destinations() {
|
|
const obj = this._readDests(),
|
|
dests = Object.create(null);
|
|
|
|
if (obj instanceof NameTree) {
|
|
const names = obj.getAll();
|
|
|
|
for (const name in names) {
|
|
dests[name] = fetchDestination(names[name]);
|
|
}
|
|
} else if (obj instanceof _primitives.Dict) {
|
|
obj.forEach(function (key, value) {
|
|
if (value) {
|
|
dests[key] = fetchDestination(value);
|
|
}
|
|
});
|
|
}
|
|
|
|
return (0, _util.shadow)(this, "destinations", dests);
|
|
}
|
|
|
|
getDestination(destinationId) {
|
|
const obj = this._readDests();
|
|
|
|
if (obj instanceof NameTree || obj instanceof _primitives.Dict) {
|
|
return fetchDestination(obj.get(destinationId) || null);
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
_readDests() {
|
|
const obj = this._catDict.get("Names");
|
|
|
|
if (obj && obj.has("Dests")) {
|
|
return new NameTree(obj.getRaw("Dests"), this.xref);
|
|
} else if (this._catDict.has("Dests")) {
|
|
return this._catDict.get("Dests");
|
|
}
|
|
|
|
return undefined;
|
|
}
|
|
|
|
get pageLabels() {
|
|
let obj = null;
|
|
|
|
try {
|
|
obj = this._readPageLabels();
|
|
} catch (ex) {
|
|
if (ex instanceof _core_utils.MissingDataException) {
|
|
throw ex;
|
|
}
|
|
|
|
(0, _util.warn)("Unable to read page labels.");
|
|
}
|
|
|
|
return (0, _util.shadow)(this, "pageLabels", obj);
|
|
}
|
|
|
|
_readPageLabels() {
|
|
const obj = this._catDict.getRaw("PageLabels");
|
|
|
|
if (!obj) {
|
|
return null;
|
|
}
|
|
|
|
const pageLabels = new Array(this.numPages);
|
|
let style = null,
|
|
prefix = "";
|
|
const numberTree = new NumberTree(obj, this.xref);
|
|
const nums = numberTree.getAll();
|
|
let currentLabel = "",
|
|
currentIndex = 1;
|
|
|
|
for (let i = 0, ii = this.numPages; i < ii; i++) {
|
|
if (i in nums) {
|
|
const labelDict = nums[i];
|
|
|
|
if (!(0, _primitives.isDict)(labelDict)) {
|
|
throw new _util.FormatError("PageLabel is not a dictionary.");
|
|
}
|
|
|
|
if (labelDict.has("Type") && !(0, _primitives.isName)(labelDict.get("Type"), "PageLabel")) {
|
|
throw new _util.FormatError("Invalid type in PageLabel dictionary.");
|
|
}
|
|
|
|
if (labelDict.has("S")) {
|
|
const s = labelDict.get("S");
|
|
|
|
if (!(0, _primitives.isName)(s)) {
|
|
throw new _util.FormatError("Invalid style in PageLabel dictionary.");
|
|
}
|
|
|
|
style = s.name;
|
|
} else {
|
|
style = null;
|
|
}
|
|
|
|
if (labelDict.has("P")) {
|
|
const p = labelDict.get("P");
|
|
|
|
if (!(0, _util.isString)(p)) {
|
|
throw new _util.FormatError("Invalid prefix in PageLabel dictionary.");
|
|
}
|
|
|
|
prefix = (0, _util.stringToPDFString)(p);
|
|
} else {
|
|
prefix = "";
|
|
}
|
|
|
|
if (labelDict.has("St")) {
|
|
const st = labelDict.get("St");
|
|
|
|
if (!(Number.isInteger(st) && st >= 1)) {
|
|
throw new _util.FormatError("Invalid start in PageLabel dictionary.");
|
|
}
|
|
|
|
currentIndex = st;
|
|
} else {
|
|
currentIndex = 1;
|
|
}
|
|
}
|
|
|
|
switch (style) {
|
|
case "D":
|
|
currentLabel = currentIndex;
|
|
break;
|
|
|
|
case "R":
|
|
case "r":
|
|
currentLabel = (0, _core_utils.toRomanNumerals)(currentIndex, style === "r");
|
|
break;
|
|
|
|
case "A":
|
|
case "a":
|
|
const LIMIT = 26;
|
|
const A_UPPER_CASE = 0x41,
|
|
A_LOWER_CASE = 0x61;
|
|
const baseCharCode = style === "a" ? A_LOWER_CASE : A_UPPER_CASE;
|
|
const letterIndex = currentIndex - 1;
|
|
const character = String.fromCharCode(baseCharCode + letterIndex % LIMIT);
|
|
const charBuf = [];
|
|
|
|
for (let j = 0, jj = letterIndex / LIMIT | 0; j <= jj; j++) {
|
|
charBuf.push(character);
|
|
}
|
|
|
|
currentLabel = charBuf.join("");
|
|
break;
|
|
|
|
default:
|
|
if (style) {
|
|
throw new _util.FormatError(`Invalid style "${style}" in PageLabel dictionary.`);
|
|
}
|
|
|
|
currentLabel = "";
|
|
}
|
|
|
|
pageLabels[i] = prefix + currentLabel;
|
|
currentIndex++;
|
|
}
|
|
|
|
return pageLabels;
|
|
}
|
|
|
|
get pageLayout() {
|
|
const obj = this._catDict.get("PageLayout");
|
|
|
|
let pageLayout = "";
|
|
|
|
if ((0, _primitives.isName)(obj)) {
|
|
switch (obj.name) {
|
|
case "SinglePage":
|
|
case "OneColumn":
|
|
case "TwoColumnLeft":
|
|
case "TwoColumnRight":
|
|
case "TwoPageLeft":
|
|
case "TwoPageRight":
|
|
pageLayout = obj.name;
|
|
}
|
|
}
|
|
|
|
return (0, _util.shadow)(this, "pageLayout", pageLayout);
|
|
}
|
|
|
|
get pageMode() {
|
|
const obj = this._catDict.get("PageMode");
|
|
|
|
let pageMode = "UseNone";
|
|
|
|
if ((0, _primitives.isName)(obj)) {
|
|
switch (obj.name) {
|
|
case "UseNone":
|
|
case "UseOutlines":
|
|
case "UseThumbs":
|
|
case "FullScreen":
|
|
case "UseOC":
|
|
case "UseAttachments":
|
|
pageMode = obj.name;
|
|
}
|
|
}
|
|
|
|
return (0, _util.shadow)(this, "pageMode", pageMode);
|
|
}
|
|
|
|
get viewerPreferences() {
|
|
const ViewerPreferencesValidators = {
|
|
HideToolbar: _util.isBool,
|
|
HideMenubar: _util.isBool,
|
|
HideWindowUI: _util.isBool,
|
|
FitWindow: _util.isBool,
|
|
CenterWindow: _util.isBool,
|
|
DisplayDocTitle: _util.isBool,
|
|
NonFullScreenPageMode: _primitives.isName,
|
|
Direction: _primitives.isName,
|
|
ViewArea: _primitives.isName,
|
|
ViewClip: _primitives.isName,
|
|
PrintArea: _primitives.isName,
|
|
PrintClip: _primitives.isName,
|
|
PrintScaling: _primitives.isName,
|
|
Duplex: _primitives.isName,
|
|
PickTrayByPDFSize: _util.isBool,
|
|
PrintPageRange: Array.isArray,
|
|
NumCopies: Number.isInteger
|
|
};
|
|
|
|
const obj = this._catDict.get("ViewerPreferences");
|
|
|
|
let prefs = null;
|
|
|
|
if ((0, _primitives.isDict)(obj)) {
|
|
for (const key in ViewerPreferencesValidators) {
|
|
if (!obj.has(key)) {
|
|
continue;
|
|
}
|
|
|
|
const value = obj.get(key);
|
|
|
|
if (!ViewerPreferencesValidators[key](value)) {
|
|
(0, _util.info)(`Bad value in ViewerPreferences for "${key}".`);
|
|
continue;
|
|
}
|
|
|
|
let prefValue;
|
|
|
|
switch (key) {
|
|
case "NonFullScreenPageMode":
|
|
switch (value.name) {
|
|
case "UseNone":
|
|
case "UseOutlines":
|
|
case "UseThumbs":
|
|
case "UseOC":
|
|
prefValue = value.name;
|
|
break;
|
|
|
|
default:
|
|
prefValue = "UseNone";
|
|
}
|
|
|
|
break;
|
|
|
|
case "Direction":
|
|
switch (value.name) {
|
|
case "L2R":
|
|
case "R2L":
|
|
prefValue = value.name;
|
|
break;
|
|
|
|
default:
|
|
prefValue = "L2R";
|
|
}
|
|
|
|
break;
|
|
|
|
case "ViewArea":
|
|
case "ViewClip":
|
|
case "PrintArea":
|
|
case "PrintClip":
|
|
switch (value.name) {
|
|
case "MediaBox":
|
|
case "CropBox":
|
|
case "BleedBox":
|
|
case "TrimBox":
|
|
case "ArtBox":
|
|
prefValue = value.name;
|
|
break;
|
|
|
|
default:
|
|
prefValue = "CropBox";
|
|
}
|
|
|
|
break;
|
|
|
|
case "PrintScaling":
|
|
switch (value.name) {
|
|
case "None":
|
|
case "AppDefault":
|
|
prefValue = value.name;
|
|
break;
|
|
|
|
default:
|
|
prefValue = "AppDefault";
|
|
}
|
|
|
|
break;
|
|
|
|
case "Duplex":
|
|
switch (value.name) {
|
|
case "Simplex":
|
|
case "DuplexFlipShortEdge":
|
|
case "DuplexFlipLongEdge":
|
|
prefValue = value.name;
|
|
break;
|
|
|
|
default:
|
|
prefValue = "None";
|
|
}
|
|
|
|
break;
|
|
|
|
case "PrintPageRange":
|
|
const length = value.length;
|
|
|
|
if (length % 2 !== 0) {
|
|
break;
|
|
}
|
|
|
|
const isValid = value.every((page, i, arr) => {
|
|
return Number.isInteger(page) && page > 0 && (i === 0 || page >= arr[i - 1]) && page <= this.numPages;
|
|
});
|
|
|
|
if (isValid) {
|
|
prefValue = value;
|
|
}
|
|
|
|
break;
|
|
|
|
case "NumCopies":
|
|
if (value > 0) {
|
|
prefValue = value;
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
if (typeof value !== "boolean") {
|
|
throw new _util.FormatError(`viewerPreferences - expected a boolean value for: ${key}`);
|
|
}
|
|
|
|
prefValue = value;
|
|
}
|
|
|
|
if (prefValue !== undefined) {
|
|
if (!prefs) {
|
|
prefs = Object.create(null);
|
|
}
|
|
|
|
prefs[key] = prefValue;
|
|
} else {
|
|
(0, _util.info)(`Bad value in ViewerPreferences for "${key}".`);
|
|
}
|
|
}
|
|
}
|
|
|
|
return (0, _util.shadow)(this, "viewerPreferences", prefs);
|
|
}
|
|
|
|
get openAction() {
|
|
const obj = this._catDict.get("OpenAction");
|
|
|
|
let openAction = null;
|
|
|
|
if ((0, _primitives.isDict)(obj)) {
|
|
const destDict = new _primitives.Dict(this.xref);
|
|
destDict.set("A", obj);
|
|
const resultObj = {
|
|
url: null,
|
|
dest: null,
|
|
action: null
|
|
};
|
|
Catalog.parseDestDictionary({
|
|
destDict,
|
|
resultObj
|
|
});
|
|
|
|
if (Array.isArray(resultObj.dest)) {
|
|
if (!openAction) {
|
|
openAction = Object.create(null);
|
|
}
|
|
|
|
openAction.dest = resultObj.dest;
|
|
} else if (resultObj.action) {
|
|
if (!openAction) {
|
|
openAction = Object.create(null);
|
|
}
|
|
|
|
openAction.action = resultObj.action;
|
|
}
|
|
} else if (Array.isArray(obj)) {
|
|
if (!openAction) {
|
|
openAction = Object.create(null);
|
|
}
|
|
|
|
openAction.dest = obj;
|
|
}
|
|
|
|
return (0, _util.shadow)(this, "openAction", openAction);
|
|
}
|
|
|
|
get attachments() {
|
|
const obj = this._catDict.get("Names");
|
|
|
|
let attachments = null;
|
|
|
|
if (obj && obj.has("EmbeddedFiles")) {
|
|
const nameTree = new NameTree(obj.getRaw("EmbeddedFiles"), this.xref);
|
|
const names = nameTree.getAll();
|
|
|
|
for (const name in names) {
|
|
const fs = new FileSpec(names[name], this.xref);
|
|
|
|
if (!attachments) {
|
|
attachments = Object.create(null);
|
|
}
|
|
|
|
attachments[(0, _util.stringToPDFString)(name)] = fs.serializable;
|
|
}
|
|
}
|
|
|
|
return (0, _util.shadow)(this, "attachments", attachments);
|
|
}
|
|
|
|
get javaScript() {
|
|
const obj = this._catDict.get("Names");
|
|
|
|
let javaScript = null;
|
|
|
|
function appendIfJavaScriptDict(jsDict) {
|
|
const type = jsDict.get("S");
|
|
|
|
if (!(0, _primitives.isName)(type, "JavaScript")) {
|
|
return;
|
|
}
|
|
|
|
let js = jsDict.get("JS");
|
|
|
|
if ((0, _primitives.isStream)(js)) {
|
|
js = (0, _util.bytesToString)(js.getBytes());
|
|
} else if (!(0, _util.isString)(js)) {
|
|
return;
|
|
}
|
|
|
|
if (!javaScript) {
|
|
javaScript = [];
|
|
}
|
|
|
|
javaScript.push((0, _util.stringToPDFString)(js));
|
|
}
|
|
|
|
if (obj && obj.has("JavaScript")) {
|
|
const nameTree = new NameTree(obj.getRaw("JavaScript"), this.xref);
|
|
const names = nameTree.getAll();
|
|
|
|
for (const name in names) {
|
|
const jsDict = names[name];
|
|
|
|
if ((0, _primitives.isDict)(jsDict)) {
|
|
appendIfJavaScriptDict(jsDict);
|
|
}
|
|
}
|
|
}
|
|
|
|
const openAction = this._catDict.get("OpenAction");
|
|
|
|
if ((0, _primitives.isDict)(openAction) && (0, _primitives.isName)(openAction.get("S"), "JavaScript")) {
|
|
appendIfJavaScriptDict(openAction);
|
|
}
|
|
|
|
return (0, _util.shadow)(this, "javaScript", javaScript);
|
|
}
|
|
|
|
fontFallback(id, handler) {
|
|
const promises = [];
|
|
this.fontCache.forEach(function (promise) {
|
|
promises.push(promise);
|
|
});
|
|
return Promise.all(promises).then(translatedFonts => {
|
|
for (const translatedFont of translatedFonts) {
|
|
if (translatedFont.loadedName === id) {
|
|
translatedFont.fallback(handler);
|
|
return;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
cleanup(manuallyTriggered = false) {
|
|
(0, _primitives.clearPrimitiveCaches)();
|
|
this.globalImageCache.clear(manuallyTriggered);
|
|
this.pageKidsCountCache.clear();
|
|
const promises = [];
|
|
this.fontCache.forEach(function (promise) {
|
|
promises.push(promise);
|
|
});
|
|
return Promise.all(promises).then(translatedFonts => {
|
|
for (const {
|
|
dict
|
|
} of translatedFonts) {
|
|
delete dict.translated;
|
|
}
|
|
|
|
this.fontCache.clear();
|
|
this.builtInCMapCache.clear();
|
|
});
|
|
}
|
|
|
|
getPageDict(pageIndex) {
|
|
const capability = (0, _util.createPromiseCapability)();
|
|
const nodesToVisit = [this._catDict.getRaw("Pages")];
|
|
const visitedNodes = new _primitives.RefSet();
|
|
const xref = this.xref,
|
|
pageKidsCountCache = this.pageKidsCountCache;
|
|
let count,
|
|
currentPageIndex = 0;
|
|
|
|
function next() {
|
|
while (nodesToVisit.length) {
|
|
const currentNode = nodesToVisit.pop();
|
|
|
|
if ((0, _primitives.isRef)(currentNode)) {
|
|
count = pageKidsCountCache.get(currentNode);
|
|
|
|
if (count > 0 && currentPageIndex + count < pageIndex) {
|
|
currentPageIndex += count;
|
|
continue;
|
|
}
|
|
|
|
if (visitedNodes.has(currentNode)) {
|
|
capability.reject(new _util.FormatError("Pages tree contains circular reference."));
|
|
return;
|
|
}
|
|
|
|
visitedNodes.put(currentNode);
|
|
xref.fetchAsync(currentNode).then(function (obj) {
|
|
if ((0, _primitives.isDict)(obj, "Page") || (0, _primitives.isDict)(obj) && !obj.has("Kids")) {
|
|
if (pageIndex === currentPageIndex) {
|
|
if (currentNode && !pageKidsCountCache.has(currentNode)) {
|
|
pageKidsCountCache.put(currentNode, 1);
|
|
}
|
|
|
|
capability.resolve([obj, currentNode]);
|
|
} else {
|
|
currentPageIndex++;
|
|
next();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
nodesToVisit.push(obj);
|
|
next();
|
|
}, capability.reject);
|
|
return;
|
|
}
|
|
|
|
if (!(0, _primitives.isDict)(currentNode)) {
|
|
capability.reject(new _util.FormatError("Page dictionary kid reference points to wrong type of object."));
|
|
return;
|
|
}
|
|
|
|
count = currentNode.get("Count");
|
|
|
|
if (Number.isInteger(count) && count >= 0) {
|
|
const objId = currentNode.objId;
|
|
|
|
if (objId && !pageKidsCountCache.has(objId)) {
|
|
pageKidsCountCache.put(objId, count);
|
|
}
|
|
|
|
if (currentPageIndex + count <= pageIndex) {
|
|
currentPageIndex += count;
|
|
continue;
|
|
}
|
|
}
|
|
|
|
const kids = currentNode.get("Kids");
|
|
|
|
if (!Array.isArray(kids)) {
|
|
if ((0, _primitives.isName)(currentNode.get("Type"), "Page") || !currentNode.has("Type") && currentNode.has("Contents")) {
|
|
if (currentPageIndex === pageIndex) {
|
|
capability.resolve([currentNode, null]);
|
|
return;
|
|
}
|
|
|
|
currentPageIndex++;
|
|
continue;
|
|
}
|
|
|
|
capability.reject(new _util.FormatError("Page dictionary kids object is not an array."));
|
|
return;
|
|
}
|
|
|
|
for (let last = kids.length - 1; last >= 0; last--) {
|
|
nodesToVisit.push(kids[last]);
|
|
}
|
|
}
|
|
|
|
capability.reject(new Error(`Page index ${pageIndex} not found.`));
|
|
}
|
|
|
|
next();
|
|
return capability.promise;
|
|
}
|
|
|
|
getPageIndex(pageRef) {
|
|
const xref = this.xref;
|
|
|
|
function pagesBeforeRef(kidRef) {
|
|
let total = 0,
|
|
parentRef;
|
|
return xref.fetchAsync(kidRef).then(function (node) {
|
|
if ((0, _primitives.isRefsEqual)(kidRef, pageRef) && !(0, _primitives.isDict)(node, "Page") && !((0, _primitives.isDict)(node) && !node.has("Type") && node.has("Contents"))) {
|
|
throw new _util.FormatError("The reference does not point to a /Page dictionary.");
|
|
}
|
|
|
|
if (!node) {
|
|
return null;
|
|
}
|
|
|
|
if (!(0, _primitives.isDict)(node)) {
|
|
throw new _util.FormatError("Node must be a dictionary.");
|
|
}
|
|
|
|
parentRef = node.getRaw("Parent");
|
|
return node.getAsync("Parent");
|
|
}).then(function (parent) {
|
|
if (!parent) {
|
|
return null;
|
|
}
|
|
|
|
if (!(0, _primitives.isDict)(parent)) {
|
|
throw new _util.FormatError("Parent must be a dictionary.");
|
|
}
|
|
|
|
return parent.getAsync("Kids");
|
|
}).then(function (kids) {
|
|
if (!kids) {
|
|
return null;
|
|
}
|
|
|
|
const kidPromises = [];
|
|
let found = false;
|
|
|
|
for (let i = 0, ii = kids.length; i < ii; i++) {
|
|
const kid = kids[i];
|
|
|
|
if (!(0, _primitives.isRef)(kid)) {
|
|
throw new _util.FormatError("Kid must be a reference.");
|
|
}
|
|
|
|
if ((0, _primitives.isRefsEqual)(kid, kidRef)) {
|
|
found = true;
|
|
break;
|
|
}
|
|
|
|
kidPromises.push(xref.fetchAsync(kid).then(function (obj) {
|
|
if (!(0, _primitives.isDict)(obj)) {
|
|
throw new _util.FormatError("Kid node must be a dictionary.");
|
|
}
|
|
|
|
if (obj.has("Count")) {
|
|
total += obj.get("Count");
|
|
} else {
|
|
total++;
|
|
}
|
|
}));
|
|
}
|
|
|
|
if (!found) {
|
|
throw new _util.FormatError("Kid reference not found in parent's kids.");
|
|
}
|
|
|
|
return Promise.all(kidPromises).then(function () {
|
|
return [total, parentRef];
|
|
});
|
|
});
|
|
}
|
|
|
|
let total = 0;
|
|
|
|
function next(ref) {
|
|
return pagesBeforeRef(ref).then(function (args) {
|
|
if (!args) {
|
|
return total;
|
|
}
|
|
|
|
const [count, parentRef] = args;
|
|
total += count;
|
|
return next(parentRef);
|
|
});
|
|
}
|
|
|
|
return next(pageRef);
|
|
}
|
|
|
|
static parseDestDictionary(params) {
|
|
function addDefaultProtocolToUrl(url) {
|
|
return url.startsWith("www.") ? `http://${url}` : url;
|
|
}
|
|
|
|
function tryConvertUrlEncoding(url) {
|
|
try {
|
|
return (0, _util.stringToUTF8String)(url);
|
|
} catch (e) {
|
|
return url;
|
|
}
|
|
}
|
|
|
|
const destDict = params.destDict;
|
|
|
|
if (!(0, _primitives.isDict)(destDict)) {
|
|
(0, _util.warn)("parseDestDictionary: `destDict` must be a dictionary.");
|
|
return;
|
|
}
|
|
|
|
const resultObj = params.resultObj;
|
|
|
|
if (typeof resultObj !== "object") {
|
|
(0, _util.warn)("parseDestDictionary: `resultObj` must be an object.");
|
|
return;
|
|
}
|
|
|
|
const docBaseUrl = params.docBaseUrl || null;
|
|
let action = destDict.get("A"),
|
|
url,
|
|
dest;
|
|
|
|
if (!(0, _primitives.isDict)(action) && destDict.has("Dest")) {
|
|
action = destDict.get("Dest");
|
|
}
|
|
|
|
if ((0, _primitives.isDict)(action)) {
|
|
const actionType = action.get("S");
|
|
|
|
if (!(0, _primitives.isName)(actionType)) {
|
|
(0, _util.warn)("parseDestDictionary: Invalid type in Action dictionary.");
|
|
return;
|
|
}
|
|
|
|
const actionName = actionType.name;
|
|
|
|
switch (actionName) {
|
|
case "URI":
|
|
url = action.get("URI");
|
|
|
|
if ((0, _primitives.isName)(url)) {
|
|
url = "/" + url.name;
|
|
} else if ((0, _util.isString)(url)) {
|
|
url = addDefaultProtocolToUrl(url);
|
|
}
|
|
|
|
break;
|
|
|
|
case "GoTo":
|
|
dest = action.get("D");
|
|
break;
|
|
|
|
case "Launch":
|
|
case "GoToR":
|
|
const urlDict = action.get("F");
|
|
|
|
if ((0, _primitives.isDict)(urlDict)) {
|
|
url = urlDict.get("F") || null;
|
|
} else if ((0, _util.isString)(urlDict)) {
|
|
url = urlDict;
|
|
}
|
|
|
|
let remoteDest = action.get("D");
|
|
|
|
if (remoteDest) {
|
|
if ((0, _primitives.isName)(remoteDest)) {
|
|
remoteDest = remoteDest.name;
|
|
}
|
|
|
|
if ((0, _util.isString)(url)) {
|
|
const baseUrl = url.split("#")[0];
|
|
|
|
if ((0, _util.isString)(remoteDest)) {
|
|
url = baseUrl + "#" + remoteDest;
|
|
} else if (Array.isArray(remoteDest)) {
|
|
url = baseUrl + "#" + JSON.stringify(remoteDest);
|
|
}
|
|
}
|
|
}
|
|
|
|
const newWindow = action.get("NewWindow");
|
|
|
|
if ((0, _util.isBool)(newWindow)) {
|
|
resultObj.newWindow = newWindow;
|
|
}
|
|
|
|
break;
|
|
|
|
case "Named":
|
|
const namedAction = action.get("N");
|
|
|
|
if ((0, _primitives.isName)(namedAction)) {
|
|
resultObj.action = namedAction.name;
|
|
}
|
|
|
|
break;
|
|
|
|
case "JavaScript":
|
|
const jsAction = action.get("JS");
|
|
let js;
|
|
|
|
if ((0, _primitives.isStream)(jsAction)) {
|
|
js = (0, _util.bytesToString)(jsAction.getBytes());
|
|
} else if ((0, _util.isString)(jsAction)) {
|
|
js = jsAction;
|
|
}
|
|
|
|
if (js) {
|
|
const URL_OPEN_METHODS = ["app.launchURL", "window.open"];
|
|
const regex = new RegExp("^\\s*(" + URL_OPEN_METHODS.join("|").split(".").join("\\.") + ")\\((?:'|\")([^'\"]*)(?:'|\")(?:,\\s*(\\w+)\\)|\\))", "i");
|
|
const jsUrl = regex.exec((0, _util.stringToPDFString)(js));
|
|
|
|
if (jsUrl && jsUrl[2]) {
|
|
url = jsUrl[2];
|
|
|
|
if (jsUrl[3] === "true" && jsUrl[1] === "app.launchURL") {
|
|
resultObj.newWindow = true;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
default:
|
|
(0, _util.warn)(`parseDestDictionary: unsupported action type "${actionName}".`);
|
|
break;
|
|
}
|
|
} else if (destDict.has("Dest")) {
|
|
dest = destDict.get("Dest");
|
|
}
|
|
|
|
if ((0, _util.isString)(url)) {
|
|
url = tryConvertUrlEncoding(url);
|
|
const absoluteUrl = (0, _util.createValidAbsoluteUrl)(url, docBaseUrl);
|
|
|
|
if (absoluteUrl) {
|
|
resultObj.url = absoluteUrl.href;
|
|
}
|
|
|
|
resultObj.unsafeUrl = url;
|
|
}
|
|
|
|
if (dest) {
|
|
if ((0, _primitives.isName)(dest)) {
|
|
dest = dest.name;
|
|
}
|
|
|
|
if ((0, _util.isString)(dest) || Array.isArray(dest)) {
|
|
resultObj.dest = dest;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
exports.Catalog = Catalog;
|
|
|
|
var XRef = function XRefClosure() {
|
|
function XRef(stream, pdfManager) {
|
|
this.stream = stream;
|
|
this.pdfManager = pdfManager;
|
|
this.entries = [];
|
|
this.xrefstms = Object.create(null);
|
|
this._cacheMap = new Map();
|
|
this.stats = {
|
|
streamTypes: Object.create(null),
|
|
fontTypes: Object.create(null)
|
|
};
|
|
this._newRefNum = null;
|
|
}
|
|
|
|
XRef.prototype = {
|
|
getNewRef: function XRef_getNewRef() {
|
|
if (this._newRefNum === null) {
|
|
this._newRefNum = this.entries.length;
|
|
}
|
|
|
|
return _primitives.Ref.get(this._newRefNum++, 0);
|
|
},
|
|
resetNewRef: function XRef_resetNewRef() {
|
|
this._newRefNum = null;
|
|
},
|
|
setStartXRef: function XRef_setStartXRef(startXRef) {
|
|
this.startXRefQueue = [startXRef];
|
|
},
|
|
parse: function XRef_parse(recoveryMode) {
|
|
var trailerDict;
|
|
|
|
if (!recoveryMode) {
|
|
trailerDict = this.readXRef();
|
|
} else {
|
|
(0, _util.warn)("Indexing all PDF objects");
|
|
trailerDict = this.indexObjects();
|
|
}
|
|
|
|
trailerDict.assignXref(this);
|
|
this.trailer = trailerDict;
|
|
let encrypt;
|
|
|
|
try {
|
|
encrypt = trailerDict.get("Encrypt");
|
|
} catch (ex) {
|
|
if (ex instanceof _core_utils.MissingDataException) {
|
|
throw ex;
|
|
}
|
|
|
|
(0, _util.warn)(`XRef.parse - Invalid "Encrypt" reference: "${ex}".`);
|
|
}
|
|
|
|
if ((0, _primitives.isDict)(encrypt)) {
|
|
var ids = trailerDict.get("ID");
|
|
var fileId = ids && ids.length ? ids[0] : "";
|
|
encrypt.suppressEncryption = true;
|
|
this.encrypt = new _crypto.CipherTransformFactory(encrypt, fileId, this.pdfManager.password);
|
|
}
|
|
|
|
let root;
|
|
|
|
try {
|
|
root = trailerDict.get("Root");
|
|
} catch (ex) {
|
|
if (ex instanceof _core_utils.MissingDataException) {
|
|
throw ex;
|
|
}
|
|
|
|
(0, _util.warn)(`XRef.parse - Invalid "Root" reference: "${ex}".`);
|
|
}
|
|
|
|
if ((0, _primitives.isDict)(root) && root.has("Pages")) {
|
|
this.root = root;
|
|
} else {
|
|
if (!recoveryMode) {
|
|
throw new _core_utils.XRefParseException();
|
|
}
|
|
|
|
throw new _util.FormatError("Invalid root reference");
|
|
}
|
|
},
|
|
processXRefTable: function XRef_processXRefTable(parser) {
|
|
if (!("tableState" in this)) {
|
|
this.tableState = {
|
|
entryNum: 0,
|
|
streamPos: parser.lexer.stream.pos,
|
|
parserBuf1: parser.buf1,
|
|
parserBuf2: parser.buf2
|
|
};
|
|
}
|
|
|
|
var obj = this.readXRefTable(parser);
|
|
|
|
if (!(0, _primitives.isCmd)(obj, "trailer")) {
|
|
throw new _util.FormatError("Invalid XRef table: could not find trailer dictionary");
|
|
}
|
|
|
|
var dict = parser.getObj();
|
|
|
|
if (!(0, _primitives.isDict)(dict) && dict.dict) {
|
|
dict = dict.dict;
|
|
}
|
|
|
|
if (!(0, _primitives.isDict)(dict)) {
|
|
throw new _util.FormatError("Invalid XRef table: could not parse trailer dictionary");
|
|
}
|
|
|
|
delete this.tableState;
|
|
return dict;
|
|
},
|
|
readXRefTable: function XRef_readXRefTable(parser) {
|
|
var stream = parser.lexer.stream;
|
|
var tableState = this.tableState;
|
|
stream.pos = tableState.streamPos;
|
|
parser.buf1 = tableState.parserBuf1;
|
|
parser.buf2 = tableState.parserBuf2;
|
|
var obj;
|
|
|
|
while (true) {
|
|
if (!("firstEntryNum" in tableState) || !("entryCount" in tableState)) {
|
|
if ((0, _primitives.isCmd)(obj = parser.getObj(), "trailer")) {
|
|
break;
|
|
}
|
|
|
|
tableState.firstEntryNum = obj;
|
|
tableState.entryCount = parser.getObj();
|
|
}
|
|
|
|
var first = tableState.firstEntryNum;
|
|
var count = tableState.entryCount;
|
|
|
|
if (!Number.isInteger(first) || !Number.isInteger(count)) {
|
|
throw new _util.FormatError("Invalid XRef table: wrong types in subsection header");
|
|
}
|
|
|
|
for (var i = tableState.entryNum; i < count; i++) {
|
|
tableState.streamPos = stream.pos;
|
|
tableState.entryNum = i;
|
|
tableState.parserBuf1 = parser.buf1;
|
|
tableState.parserBuf2 = parser.buf2;
|
|
var entry = {};
|
|
entry.offset = parser.getObj();
|
|
entry.gen = parser.getObj();
|
|
var type = parser.getObj();
|
|
|
|
if (type instanceof _primitives.Cmd) {
|
|
switch (type.cmd) {
|
|
case "f":
|
|
entry.free = true;
|
|
break;
|
|
|
|
case "n":
|
|
entry.uncompressed = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!Number.isInteger(entry.offset) || !Number.isInteger(entry.gen) || !(entry.free || entry.uncompressed)) {
|
|
throw new _util.FormatError(`Invalid entry in XRef subsection: ${first}, ${count}`);
|
|
}
|
|
|
|
if (i === 0 && entry.free && first === 1) {
|
|
first = 0;
|
|
}
|
|
|
|
if (!this.entries[i + first]) {
|
|
this.entries[i + first] = entry;
|
|
}
|
|
}
|
|
|
|
tableState.entryNum = 0;
|
|
tableState.streamPos = stream.pos;
|
|
tableState.parserBuf1 = parser.buf1;
|
|
tableState.parserBuf2 = parser.buf2;
|
|
delete tableState.firstEntryNum;
|
|
delete tableState.entryCount;
|
|
}
|
|
|
|
if (this.entries[0] && !this.entries[0].free) {
|
|
throw new _util.FormatError("Invalid XRef table: unexpected first object");
|
|
}
|
|
|
|
return obj;
|
|
},
|
|
processXRefStream: function XRef_processXRefStream(stream) {
|
|
if (!("streamState" in this)) {
|
|
var streamParameters = stream.dict;
|
|
var byteWidths = streamParameters.get("W");
|
|
var range = streamParameters.get("Index");
|
|
|
|
if (!range) {
|
|
range = [0, streamParameters.get("Size")];
|
|
}
|
|
|
|
this.streamState = {
|
|
entryRanges: range,
|
|
byteWidths,
|
|
entryNum: 0,
|
|
streamPos: stream.pos
|
|
};
|
|
}
|
|
|
|
this.readXRefStream(stream);
|
|
delete this.streamState;
|
|
return stream.dict;
|
|
},
|
|
readXRefStream: function XRef_readXRefStream(stream) {
|
|
var i, j;
|
|
var streamState = this.streamState;
|
|
stream.pos = streamState.streamPos;
|
|
var byteWidths = streamState.byteWidths;
|
|
var typeFieldWidth = byteWidths[0];
|
|
var offsetFieldWidth = byteWidths[1];
|
|
var generationFieldWidth = byteWidths[2];
|
|
var entryRanges = streamState.entryRanges;
|
|
|
|
while (entryRanges.length > 0) {
|
|
var first = entryRanges[0];
|
|
var n = entryRanges[1];
|
|
|
|
if (!Number.isInteger(first) || !Number.isInteger(n)) {
|
|
throw new _util.FormatError(`Invalid XRef range fields: ${first}, ${n}`);
|
|
}
|
|
|
|
if (!Number.isInteger(typeFieldWidth) || !Number.isInteger(offsetFieldWidth) || !Number.isInteger(generationFieldWidth)) {
|
|
throw new _util.FormatError(`Invalid XRef entry fields length: ${first}, ${n}`);
|
|
}
|
|
|
|
for (i = streamState.entryNum; i < n; ++i) {
|
|
streamState.entryNum = i;
|
|
streamState.streamPos = stream.pos;
|
|
var type = 0,
|
|
offset = 0,
|
|
generation = 0;
|
|
|
|
for (j = 0; j < typeFieldWidth; ++j) {
|
|
type = type << 8 | stream.getByte();
|
|
}
|
|
|
|
if (typeFieldWidth === 0) {
|
|
type = 1;
|
|
}
|
|
|
|
for (j = 0; j < offsetFieldWidth; ++j) {
|
|
offset = offset << 8 | stream.getByte();
|
|
}
|
|
|
|
for (j = 0; j < generationFieldWidth; ++j) {
|
|
generation = generation << 8 | stream.getByte();
|
|
}
|
|
|
|
var entry = {};
|
|
entry.offset = offset;
|
|
entry.gen = generation;
|
|
|
|
switch (type) {
|
|
case 0:
|
|
entry.free = true;
|
|
break;
|
|
|
|
case 1:
|
|
entry.uncompressed = true;
|
|
break;
|
|
|
|
case 2:
|
|
break;
|
|
|
|
default:
|
|
throw new _util.FormatError(`Invalid XRef entry type: ${type}`);
|
|
}
|
|
|
|
if (!this.entries[first + i]) {
|
|
this.entries[first + i] = entry;
|
|
}
|
|
}
|
|
|
|
streamState.entryNum = 0;
|
|
streamState.streamPos = stream.pos;
|
|
entryRanges.splice(0, 2);
|
|
}
|
|
},
|
|
indexObjects: function XRef_indexObjects() {
|
|
var TAB = 0x9,
|
|
LF = 0xa,
|
|
CR = 0xd,
|
|
SPACE = 0x20;
|
|
var PERCENT = 0x25,
|
|
LT = 0x3c;
|
|
|
|
function readToken(data, offset) {
|
|
var token = "",
|
|
ch = data[offset];
|
|
|
|
while (ch !== LF && ch !== CR && ch !== LT) {
|
|
if (++offset >= data.length) {
|
|
break;
|
|
}
|
|
|
|
token += String.fromCharCode(ch);
|
|
ch = data[offset];
|
|
}
|
|
|
|
return token;
|
|
}
|
|
|
|
function skipUntil(data, offset, what) {
|
|
var length = what.length,
|
|
dataLength = data.length;
|
|
var skipped = 0;
|
|
|
|
while (offset < dataLength) {
|
|
var i = 0;
|
|
|
|
while (i < length && data[offset + i] === what[i]) {
|
|
++i;
|
|
}
|
|
|
|
if (i >= length) {
|
|
break;
|
|
}
|
|
|
|
offset++;
|
|
skipped++;
|
|
}
|
|
|
|
return skipped;
|
|
}
|
|
|
|
var objRegExp = /^(\d+)\s+(\d+)\s+obj\b/;
|
|
const endobjRegExp = /\bendobj[\b\s]$/;
|
|
const nestedObjRegExp = /\s+(\d+\s+\d+\s+obj[\b\s<])$/;
|
|
const CHECK_CONTENT_LENGTH = 25;
|
|
var trailerBytes = new Uint8Array([116, 114, 97, 105, 108, 101, 114]);
|
|
var startxrefBytes = new Uint8Array([115, 116, 97, 114, 116, 120, 114, 101, 102]);
|
|
const objBytes = new Uint8Array([111, 98, 106]);
|
|
var xrefBytes = new Uint8Array([47, 88, 82, 101, 102]);
|
|
this.entries.length = 0;
|
|
var stream = this.stream;
|
|
stream.pos = 0;
|
|
var buffer = stream.getBytes();
|
|
var position = stream.start,
|
|
length = buffer.length;
|
|
var trailers = [],
|
|
xrefStms = [];
|
|
|
|
while (position < length) {
|
|
var ch = buffer[position];
|
|
|
|
if (ch === TAB || ch === LF || ch === CR || ch === SPACE) {
|
|
++position;
|
|
continue;
|
|
}
|
|
|
|
if (ch === PERCENT) {
|
|
do {
|
|
++position;
|
|
|
|
if (position >= length) {
|
|
break;
|
|
}
|
|
|
|
ch = buffer[position];
|
|
} while (ch !== LF && ch !== CR);
|
|
|
|
continue;
|
|
}
|
|
|
|
var token = readToken(buffer, position);
|
|
var m;
|
|
|
|
if (token.startsWith("xref") && (token.length === 4 || /\s/.test(token[4]))) {
|
|
position += skipUntil(buffer, position, trailerBytes);
|
|
trailers.push(position);
|
|
position += skipUntil(buffer, position, startxrefBytes);
|
|
} else if (m = objRegExp.exec(token)) {
|
|
const num = m[1] | 0,
|
|
gen = m[2] | 0;
|
|
|
|
if (!this.entries[num] || this.entries[num].gen === gen) {
|
|
this.entries[num] = {
|
|
offset: position - stream.start,
|
|
gen,
|
|
uncompressed: true
|
|
};
|
|
}
|
|
|
|
let contentLength,
|
|
startPos = position + token.length;
|
|
|
|
while (startPos < buffer.length) {
|
|
const endPos = startPos + skipUntil(buffer, startPos, objBytes) + 4;
|
|
contentLength = endPos - position;
|
|
const checkPos = Math.max(endPos - CHECK_CONTENT_LENGTH, startPos);
|
|
const tokenStr = (0, _util.bytesToString)(buffer.subarray(checkPos, endPos));
|
|
|
|
if (endobjRegExp.test(tokenStr)) {
|
|
break;
|
|
} else {
|
|
const objToken = nestedObjRegExp.exec(tokenStr);
|
|
|
|
if (objToken && objToken[1]) {
|
|
(0, _util.warn)('indexObjects: Found new "obj" inside of another "obj", ' + 'caused by missing "endobj" -- trying to recover.');
|
|
contentLength -= objToken[1].length;
|
|
break;
|
|
}
|
|
}
|
|
|
|
startPos = endPos;
|
|
}
|
|
|
|
const content = buffer.subarray(position, position + contentLength);
|
|
var xrefTagOffset = skipUntil(content, 0, xrefBytes);
|
|
|
|
if (xrefTagOffset < contentLength && content[xrefTagOffset + 5] < 64) {
|
|
xrefStms.push(position - stream.start);
|
|
this.xrefstms[position - stream.start] = 1;
|
|
}
|
|
|
|
position += contentLength;
|
|
} else if (token.startsWith("trailer") && (token.length === 7 || /\s/.test(token[7]))) {
|
|
trailers.push(position);
|
|
position += skipUntil(buffer, position, startxrefBytes);
|
|
} else {
|
|
position += token.length + 1;
|
|
}
|
|
}
|
|
|
|
var i, ii;
|
|
|
|
for (i = 0, ii = xrefStms.length; i < ii; ++i) {
|
|
this.startXRefQueue.push(xrefStms[i]);
|
|
this.readXRef(true);
|
|
}
|
|
|
|
let trailerDict;
|
|
|
|
for (i = 0, ii = trailers.length; i < ii; ++i) {
|
|
stream.pos = trailers[i];
|
|
const parser = new _parser.Parser({
|
|
lexer: new _parser.Lexer(stream),
|
|
xref: this,
|
|
allowStreams: true,
|
|
recoveryMode: true
|
|
});
|
|
var obj = parser.getObj();
|
|
|
|
if (!(0, _primitives.isCmd)(obj, "trailer")) {
|
|
continue;
|
|
}
|
|
|
|
const dict = parser.getObj();
|
|
|
|
if (!(0, _primitives.isDict)(dict)) {
|
|
continue;
|
|
}
|
|
|
|
let rootDict;
|
|
|
|
try {
|
|
rootDict = dict.get("Root");
|
|
} catch (ex) {
|
|
if (ex instanceof _core_utils.MissingDataException) {
|
|
throw ex;
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
if (!(0, _primitives.isDict)(rootDict) || !rootDict.has("Pages")) {
|
|
continue;
|
|
}
|
|
|
|
if (dict.has("ID")) {
|
|
return dict;
|
|
}
|
|
|
|
trailerDict = dict;
|
|
}
|
|
|
|
if (trailerDict) {
|
|
return trailerDict;
|
|
}
|
|
|
|
throw new _util.InvalidPDFException("Invalid PDF structure.");
|
|
},
|
|
readXRef: function XRef_readXRef(recoveryMode) {
|
|
var stream = this.stream;
|
|
const startXRefParsedCache = Object.create(null);
|
|
|
|
try {
|
|
while (this.startXRefQueue.length) {
|
|
var startXRef = this.startXRefQueue[0];
|
|
|
|
if (startXRefParsedCache[startXRef]) {
|
|
(0, _util.warn)("readXRef - skipping XRef table since it was already parsed.");
|
|
this.startXRefQueue.shift();
|
|
continue;
|
|
}
|
|
|
|
startXRefParsedCache[startXRef] = true;
|
|
stream.pos = startXRef + stream.start;
|
|
const parser = new _parser.Parser({
|
|
lexer: new _parser.Lexer(stream),
|
|
xref: this,
|
|
allowStreams: true
|
|
});
|
|
var obj = parser.getObj();
|
|
var dict;
|
|
|
|
if ((0, _primitives.isCmd)(obj, "xref")) {
|
|
dict = this.processXRefTable(parser);
|
|
|
|
if (!this.topDict) {
|
|
this.topDict = dict;
|
|
}
|
|
|
|
obj = dict.get("XRefStm");
|
|
|
|
if (Number.isInteger(obj)) {
|
|
var pos = obj;
|
|
|
|
if (!(pos in this.xrefstms)) {
|
|
this.xrefstms[pos] = 1;
|
|
this.startXRefQueue.push(pos);
|
|
}
|
|
}
|
|
} else if (Number.isInteger(obj)) {
|
|
if (!Number.isInteger(parser.getObj()) || !(0, _primitives.isCmd)(parser.getObj(), "obj") || !(0, _primitives.isStream)(obj = parser.getObj())) {
|
|
throw new _util.FormatError("Invalid XRef stream");
|
|
}
|
|
|
|
dict = this.processXRefStream(obj);
|
|
|
|
if (!this.topDict) {
|
|
this.topDict = dict;
|
|
}
|
|
|
|
if (!dict) {
|
|
throw new _util.FormatError("Failed to read XRef stream");
|
|
}
|
|
} else {
|
|
throw new _util.FormatError("Invalid XRef stream header");
|
|
}
|
|
|
|
obj = dict.get("Prev");
|
|
|
|
if (Number.isInteger(obj)) {
|
|
this.startXRefQueue.push(obj);
|
|
} else if ((0, _primitives.isRef)(obj)) {
|
|
this.startXRefQueue.push(obj.num);
|
|
}
|
|
|
|
this.startXRefQueue.shift();
|
|
}
|
|
|
|
return this.topDict;
|
|
} catch (e) {
|
|
if (e instanceof _core_utils.MissingDataException) {
|
|
throw e;
|
|
}
|
|
|
|
(0, _util.info)("(while reading XRef): " + e);
|
|
}
|
|
|
|
if (recoveryMode) {
|
|
return undefined;
|
|
}
|
|
|
|
throw new _core_utils.XRefParseException();
|
|
},
|
|
getEntry: function XRef_getEntry(i) {
|
|
var xrefEntry = this.entries[i];
|
|
|
|
if (xrefEntry && !xrefEntry.free && xrefEntry.offset) {
|
|
return xrefEntry;
|
|
}
|
|
|
|
return null;
|
|
},
|
|
fetchIfRef: function XRef_fetchIfRef(obj, suppressEncryption) {
|
|
if (obj instanceof _primitives.Ref) {
|
|
return this.fetch(obj, suppressEncryption);
|
|
}
|
|
|
|
return obj;
|
|
},
|
|
fetch: function XRef_fetch(ref, suppressEncryption) {
|
|
if (!(ref instanceof _primitives.Ref)) {
|
|
throw new Error("ref object is not a reference");
|
|
}
|
|
|
|
const num = ref.num;
|
|
|
|
const cacheEntry = this._cacheMap.get(num);
|
|
|
|
if (cacheEntry !== undefined) {
|
|
if (cacheEntry instanceof _primitives.Dict && !cacheEntry.objId) {
|
|
cacheEntry.objId = ref.toString();
|
|
}
|
|
|
|
return cacheEntry;
|
|
}
|
|
|
|
let xrefEntry = this.getEntry(num);
|
|
|
|
if (xrefEntry === null) {
|
|
this._cacheMap.set(num, xrefEntry);
|
|
|
|
return xrefEntry;
|
|
}
|
|
|
|
if (xrefEntry.uncompressed) {
|
|
xrefEntry = this.fetchUncompressed(ref, xrefEntry, suppressEncryption);
|
|
} else {
|
|
xrefEntry = this.fetchCompressed(ref, xrefEntry, suppressEncryption);
|
|
}
|
|
|
|
if ((0, _primitives.isDict)(xrefEntry)) {
|
|
xrefEntry.objId = ref.toString();
|
|
} else if ((0, _primitives.isStream)(xrefEntry)) {
|
|
xrefEntry.dict.objId = ref.toString();
|
|
}
|
|
|
|
return xrefEntry;
|
|
},
|
|
|
|
fetchUncompressed(ref, xrefEntry, suppressEncryption = false) {
|
|
var gen = ref.gen;
|
|
var num = ref.num;
|
|
|
|
if (xrefEntry.gen !== gen) {
|
|
throw new _core_utils.XRefEntryException(`Inconsistent generation in XRef: ${ref}`);
|
|
}
|
|
|
|
var stream = this.stream.makeSubStream(xrefEntry.offset + this.stream.start);
|
|
const parser = new _parser.Parser({
|
|
lexer: new _parser.Lexer(stream),
|
|
xref: this,
|
|
allowStreams: true
|
|
});
|
|
var obj1 = parser.getObj();
|
|
var obj2 = parser.getObj();
|
|
var obj3 = parser.getObj();
|
|
|
|
if (obj1 !== num || obj2 !== gen || !(obj3 instanceof _primitives.Cmd)) {
|
|
throw new _core_utils.XRefEntryException(`Bad (uncompressed) XRef entry: ${ref}`);
|
|
}
|
|
|
|
if (obj3.cmd !== "obj") {
|
|
if (obj3.cmd.startsWith("obj")) {
|
|
num = parseInt(obj3.cmd.substring(3), 10);
|
|
|
|
if (!Number.isNaN(num)) {
|
|
return num;
|
|
}
|
|
}
|
|
|
|
throw new _core_utils.XRefEntryException(`Bad (uncompressed) XRef entry: ${ref}`);
|
|
}
|
|
|
|
if (this.encrypt && !suppressEncryption) {
|
|
xrefEntry = parser.getObj(this.encrypt.createCipherTransform(num, gen));
|
|
} else {
|
|
xrefEntry = parser.getObj();
|
|
}
|
|
|
|
if (!(0, _primitives.isStream)(xrefEntry)) {
|
|
this._cacheMap.set(num, xrefEntry);
|
|
}
|
|
|
|
return xrefEntry;
|
|
},
|
|
|
|
fetchCompressed(ref, xrefEntry, suppressEncryption = false) {
|
|
const tableOffset = xrefEntry.offset;
|
|
const stream = this.fetch(_primitives.Ref.get(tableOffset, 0));
|
|
|
|
if (!(0, _primitives.isStream)(stream)) {
|
|
throw new _util.FormatError("bad ObjStm stream");
|
|
}
|
|
|
|
const first = stream.dict.get("First");
|
|
const n = stream.dict.get("N");
|
|
|
|
if (!Number.isInteger(first) || !Number.isInteger(n)) {
|
|
throw new _util.FormatError("invalid first and n parameters for ObjStm stream");
|
|
}
|
|
|
|
const parser = new _parser.Parser({
|
|
lexer: new _parser.Lexer(stream),
|
|
xref: this,
|
|
allowStreams: true
|
|
});
|
|
const nums = new Array(n);
|
|
|
|
for (let i = 0; i < n; ++i) {
|
|
const num = parser.getObj();
|
|
|
|
if (!Number.isInteger(num)) {
|
|
throw new _util.FormatError(`invalid object number in the ObjStm stream: ${num}`);
|
|
}
|
|
|
|
const offset = parser.getObj();
|
|
|
|
if (!Number.isInteger(offset)) {
|
|
throw new _util.FormatError(`invalid object offset in the ObjStm stream: ${offset}`);
|
|
}
|
|
|
|
nums[i] = num;
|
|
}
|
|
|
|
const entries = new Array(n);
|
|
|
|
for (let i = 0; i < n; ++i) {
|
|
const obj = parser.getObj();
|
|
entries[i] = obj;
|
|
|
|
if (parser.buf1 instanceof _primitives.Cmd && parser.buf1.cmd === "endobj") {
|
|
parser.shift();
|
|
}
|
|
|
|
if ((0, _primitives.isStream)(obj)) {
|
|
continue;
|
|
}
|
|
|
|
const num = nums[i],
|
|
entry = this.entries[num];
|
|
|
|
if (entry && entry.offset === tableOffset && entry.gen === i) {
|
|
this._cacheMap.set(num, obj);
|
|
}
|
|
}
|
|
|
|
xrefEntry = entries[xrefEntry.gen];
|
|
|
|
if (xrefEntry === undefined) {
|
|
throw new _core_utils.XRefEntryException(`Bad (compressed) XRef entry: ${ref}`);
|
|
}
|
|
|
|
return xrefEntry;
|
|
},
|
|
|
|
async fetchIfRefAsync(obj, suppressEncryption) {
|
|
if (obj instanceof _primitives.Ref) {
|
|
return this.fetchAsync(obj, suppressEncryption);
|
|
}
|
|
|
|
return obj;
|
|
},
|
|
|
|
async fetchAsync(ref, suppressEncryption) {
|
|
try {
|
|
return this.fetch(ref, suppressEncryption);
|
|
} catch (ex) {
|
|
if (!(ex instanceof _core_utils.MissingDataException)) {
|
|
throw ex;
|
|
}
|
|
|
|
await this.pdfManager.requestRange(ex.begin, ex.end);
|
|
return this.fetchAsync(ref, suppressEncryption);
|
|
}
|
|
},
|
|
|
|
getCatalogObj: function XRef_getCatalogObj() {
|
|
return this.root;
|
|
}
|
|
};
|
|
return XRef;
|
|
}();
|
|
|
|
exports.XRef = XRef;
|
|
|
|
class NameOrNumberTree {
|
|
constructor(root, xref, type) {
|
|
if (this.constructor === NameOrNumberTree) {
|
|
(0, _util.unreachable)("Cannot initialize NameOrNumberTree.");
|
|
}
|
|
|
|
this.root = root;
|
|
this.xref = xref;
|
|
this._type = type;
|
|
}
|
|
|
|
getAll() {
|
|
const dict = Object.create(null);
|
|
|
|
if (!this.root) {
|
|
return dict;
|
|
}
|
|
|
|
const xref = this.xref;
|
|
const processed = new _primitives.RefSet();
|
|
processed.put(this.root);
|
|
const queue = [this.root];
|
|
|
|
while (queue.length > 0) {
|
|
const obj = xref.fetchIfRef(queue.shift());
|
|
|
|
if (!(0, _primitives.isDict)(obj)) {
|
|
continue;
|
|
}
|
|
|
|
if (obj.has("Kids")) {
|
|
const kids = obj.get("Kids");
|
|
|
|
for (let i = 0, ii = kids.length; i < ii; i++) {
|
|
const kid = kids[i];
|
|
|
|
if (processed.has(kid)) {
|
|
throw new _util.FormatError(`Duplicate entry in "${this._type}" tree.`);
|
|
}
|
|
|
|
queue.push(kid);
|
|
processed.put(kid);
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
const entries = obj.get(this._type);
|
|
|
|
if (Array.isArray(entries)) {
|
|
for (let i = 0, ii = entries.length; i < ii; i += 2) {
|
|
dict[xref.fetchIfRef(entries[i])] = xref.fetchIfRef(entries[i + 1]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return dict;
|
|
}
|
|
|
|
get(key) {
|
|
if (!this.root) {
|
|
return null;
|
|
}
|
|
|
|
const xref = this.xref;
|
|
let kidsOrEntries = xref.fetchIfRef(this.root);
|
|
let loopCount = 0;
|
|
const MAX_LEVELS = 10;
|
|
|
|
while (kidsOrEntries.has("Kids")) {
|
|
if (++loopCount > MAX_LEVELS) {
|
|
(0, _util.warn)(`Search depth limit reached for "${this._type}" tree.`);
|
|
return null;
|
|
}
|
|
|
|
const kids = kidsOrEntries.get("Kids");
|
|
|
|
if (!Array.isArray(kids)) {
|
|
return null;
|
|
}
|
|
|
|
let l = 0,
|
|
r = kids.length - 1;
|
|
|
|
while (l <= r) {
|
|
const m = l + r >> 1;
|
|
const kid = xref.fetchIfRef(kids[m]);
|
|
const limits = kid.get("Limits");
|
|
|
|
if (key < xref.fetchIfRef(limits[0])) {
|
|
r = m - 1;
|
|
} else if (key > xref.fetchIfRef(limits[1])) {
|
|
l = m + 1;
|
|
} else {
|
|
kidsOrEntries = xref.fetchIfRef(kids[m]);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (l > r) {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
const entries = kidsOrEntries.get(this._type);
|
|
|
|
if (Array.isArray(entries)) {
|
|
let l = 0,
|
|
r = entries.length - 2;
|
|
|
|
while (l <= r) {
|
|
const tmp = l + r >> 1,
|
|
m = tmp + (tmp & 1);
|
|
const currentKey = xref.fetchIfRef(entries[m]);
|
|
|
|
if (key < currentKey) {
|
|
r = m - 2;
|
|
} else if (key > currentKey) {
|
|
l = m + 2;
|
|
} else {
|
|
return xref.fetchIfRef(entries[m + 1]);
|
|
}
|
|
}
|
|
|
|
(0, _util.info)(`Falling back to an exhaustive search, for key "${key}", ` + `in "${this._type}" tree.`);
|
|
|
|
for (let m = 0, mm = entries.length; m < mm; m += 2) {
|
|
const currentKey = xref.fetchIfRef(entries[m]);
|
|
|
|
if (currentKey === key) {
|
|
(0, _util.warn)(`The "${key}" key was found at an incorrect, ` + `i.e. out-of-order, position in "${this._type}" tree.`);
|
|
return xref.fetchIfRef(entries[m + 1]);
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
}
|
|
|
|
class NameTree extends NameOrNumberTree {
|
|
constructor(root, xref) {
|
|
super(root, xref, "Names");
|
|
}
|
|
|
|
}
|
|
|
|
class NumberTree extends NameOrNumberTree {
|
|
constructor(root, xref) {
|
|
super(root, xref, "Nums");
|
|
}
|
|
|
|
}
|
|
|
|
var FileSpec = function FileSpecClosure() {
|
|
function FileSpec(root, xref) {
|
|
if (!root || !(0, _primitives.isDict)(root)) {
|
|
return;
|
|
}
|
|
|
|
this.xref = xref;
|
|
this.root = root;
|
|
|
|
if (root.has("FS")) {
|
|
this.fs = root.get("FS");
|
|
}
|
|
|
|
this.description = root.has("Desc") ? (0, _util.stringToPDFString)(root.get("Desc")) : "";
|
|
|
|
if (root.has("RF")) {
|
|
(0, _util.warn)("Related file specifications are not supported");
|
|
}
|
|
|
|
this.contentAvailable = true;
|
|
|
|
if (!root.has("EF")) {
|
|
this.contentAvailable = false;
|
|
(0, _util.warn)("Non-embedded file specifications are not supported");
|
|
}
|
|
}
|
|
|
|
function pickPlatformItem(dict) {
|
|
if (dict.has("UF")) {
|
|
return dict.get("UF");
|
|
} else if (dict.has("F")) {
|
|
return dict.get("F");
|
|
} else if (dict.has("Unix")) {
|
|
return dict.get("Unix");
|
|
} else if (dict.has("Mac")) {
|
|
return dict.get("Mac");
|
|
} else if (dict.has("DOS")) {
|
|
return dict.get("DOS");
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
FileSpec.prototype = {
|
|
get filename() {
|
|
if (!this._filename && this.root) {
|
|
var filename = pickPlatformItem(this.root) || "unnamed";
|
|
this._filename = (0, _util.stringToPDFString)(filename).replace(/\\\\/g, "\\").replace(/\\\//g, "/").replace(/\\/g, "/");
|
|
}
|
|
|
|
return this._filename;
|
|
},
|
|
|
|
get content() {
|
|
if (!this.contentAvailable) {
|
|
return null;
|
|
}
|
|
|
|
if (!this.contentRef && this.root) {
|
|
this.contentRef = pickPlatformItem(this.root.get("EF"));
|
|
}
|
|
|
|
var content = null;
|
|
|
|
if (this.contentRef) {
|
|
var xref = this.xref;
|
|
var fileObj = xref.fetchIfRef(this.contentRef);
|
|
|
|
if (fileObj && (0, _primitives.isStream)(fileObj)) {
|
|
content = fileObj.getBytes();
|
|
} else {
|
|
(0, _util.warn)("Embedded file specification points to non-existing/invalid " + "content");
|
|
}
|
|
} else {
|
|
(0, _util.warn)("Embedded file specification does not have a content");
|
|
}
|
|
|
|
return content;
|
|
},
|
|
|
|
get serializable() {
|
|
return {
|
|
filename: this.filename,
|
|
content: this.content
|
|
};
|
|
}
|
|
|
|
};
|
|
return FileSpec;
|
|
}();
|
|
|
|
exports.FileSpec = FileSpec;
|
|
|
|
const ObjectLoader = function () {
|
|
function mayHaveChildren(value) {
|
|
return value instanceof _primitives.Ref || value instanceof _primitives.Dict || Array.isArray(value) || (0, _primitives.isStream)(value);
|
|
}
|
|
|
|
function addChildren(node, nodesToVisit) {
|
|
if (node instanceof _primitives.Dict) {
|
|
node = node.getRawValues();
|
|
} else if ((0, _primitives.isStream)(node)) {
|
|
node = node.dict.getRawValues();
|
|
} else if (!Array.isArray(node)) {
|
|
return;
|
|
}
|
|
|
|
for (const rawValue of node) {
|
|
if (mayHaveChildren(rawValue)) {
|
|
nodesToVisit.push(rawValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
function ObjectLoader(dict, keys, xref) {
|
|
this.dict = dict;
|
|
this.keys = keys;
|
|
this.xref = xref;
|
|
this.refSet = null;
|
|
}
|
|
|
|
ObjectLoader.prototype = {
|
|
async load() {
|
|
if (!this.xref.stream.allChunksLoaded || this.xref.stream.allChunksLoaded()) {
|
|
return undefined;
|
|
}
|
|
|
|
const {
|
|
keys,
|
|
dict
|
|
} = this;
|
|
this.refSet = new _primitives.RefSet();
|
|
const nodesToVisit = [];
|
|
|
|
for (let i = 0, ii = keys.length; i < ii; i++) {
|
|
const rawValue = dict.getRaw(keys[i]);
|
|
|
|
if (rawValue !== undefined) {
|
|
nodesToVisit.push(rawValue);
|
|
}
|
|
}
|
|
|
|
return this._walk(nodesToVisit);
|
|
},
|
|
|
|
async _walk(nodesToVisit) {
|
|
const nodesToRevisit = [];
|
|
const pendingRequests = [];
|
|
|
|
while (nodesToVisit.length) {
|
|
let currentNode = nodesToVisit.pop();
|
|
|
|
if (currentNode instanceof _primitives.Ref) {
|
|
if (this.refSet.has(currentNode)) {
|
|
continue;
|
|
}
|
|
|
|
try {
|
|
this.refSet.put(currentNode);
|
|
currentNode = this.xref.fetch(currentNode);
|
|
} catch (ex) {
|
|
if (!(ex instanceof _core_utils.MissingDataException)) {
|
|
throw ex;
|
|
}
|
|
|
|
nodesToRevisit.push(currentNode);
|
|
pendingRequests.push({
|
|
begin: ex.begin,
|
|
end: ex.end
|
|
});
|
|
}
|
|
}
|
|
|
|
if (currentNode && currentNode.getBaseStreams) {
|
|
const baseStreams = currentNode.getBaseStreams();
|
|
let foundMissingData = false;
|
|
|
|
for (let i = 0, ii = baseStreams.length; i < ii; i++) {
|
|
const stream = baseStreams[i];
|
|
|
|
if (stream.allChunksLoaded && !stream.allChunksLoaded()) {
|
|
foundMissingData = true;
|
|
pendingRequests.push({
|
|
begin: stream.start,
|
|
end: stream.end
|
|
});
|
|
}
|
|
}
|
|
|
|
if (foundMissingData) {
|
|
nodesToRevisit.push(currentNode);
|
|
}
|
|
}
|
|
|
|
addChildren(currentNode, nodesToVisit);
|
|
}
|
|
|
|
if (pendingRequests.length) {
|
|
await this.xref.stream.manager.requestRanges(pendingRequests);
|
|
|
|
for (let i = 0, ii = nodesToRevisit.length; i < ii; i++) {
|
|
const node = nodesToRevisit[i];
|
|
|
|
if (node instanceof _primitives.Ref) {
|
|
this.refSet.remove(node);
|
|
}
|
|
}
|
|
|
|
return this._walk(nodesToRevisit);
|
|
}
|
|
|
|
this.refSet = null;
|
|
return undefined;
|
|
}
|
|
|
|
};
|
|
return ObjectLoader;
|
|
}();
|
|
|
|
exports.ObjectLoader = ObjectLoader; |