text: /* Copyright 2012 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.
   */
  /* eslint no-var: error */
  
  import {
    assert, bytesToString, FormatError, info, isArrayBuffer, isArrayEqual, isBool,
    isNum, isSpace, isString, OPS, shadow, stringToBytes, stringToPDFString, Util,
    warn
  } from '../shared/util';
  import { Catalog, ObjectLoader, XRef } from './obj';
  import { Dict, isDict, isName, isStream, Ref } from './primitives';
  import {
    getInheritableProperty, MissingDataException, XRefEntryException,
    XRefParseException
  } from './core_utils';
  import { NullStream, Stream, StreamsSequenceStream } from './stream';
  import { AnnotationFactory } from './annotation';
  import { calculateMD5 } from './crypto';
  import { Linearization } from './parser';
  import { OperatorList } from './operator_list';
  import { PartialEvaluator } from './evaluator';
  import { PDFFunctionFactory } from './function';
  
  const DEFAULT_USER_UNIT = 1.0;
  const LETTER_SIZE_MEDIABOX = [0, 0, 612, 792];
  
  function isAnnotationRenderable(annotation, intent) {
    return (intent === 'display' && annotation.viewable) ||
           (intent === 'print' && annotation.printable);
  }
  
  class Page {
    constructor({ pdfManager, xref, pageIndex, pageDict, ref, fontCache,
                  builtInCMapCache, pdfFunctionFactory, }) {
      this.pdfManager = pdfManager;
      this.pageIndex = pageIndex;
      this.pageDict = pageDict;
      this.xref = xref;
      this.ref = ref;
      this.fontCache = fontCache;
      this.builtInCMapCache = builtInCMapCache;
      this.pdfFunctionFactory = pdfFunctionFactory;
      this.evaluatorOptions = pdfManager.evaluatorOptions;
      this.resourcesPromise = null;
  
      const idCounters = {
        obj: 0,
      };
      this.idFactory = {
        createObjId() {
          return `p${pageIndex}_${++idCounters.obj}`;
        },
        getDocId() {
          return `g_${pdfManager.docId}`;
        },
      };
    }
  
    /**
     * @private
     */
    _getInheritableProperty(key, getArray = false) {
      const value = getInheritableProperty({ dict: this.pageDict, key, getArray,
                                             stopWhenFound: false, });
      if (!Array.isArray(value)) {
        return value;
      }
      if (value.length === 1 || !isDict(value[0])) {
        return value[0];
      }
      return Dict.merge(this.xref, value);
    }
  
    get content() {
      return this.pageDict.get('Contents');
    }
  
    get resources() {
      // For robustness: The spec states that a \Resources entry has to be
      // present, but can be empty. Some documents still omit it; in this case
      // we return an empty dictionary.
      return shadow(this, 'resources',
                    this._getInheritableProperty('Resources') || Dict.empty);
    }
  
    _getBoundingBox(name) {
      const box = this._getInheritableProperty(name, /* getArray = */ true);
  
      if (Array.isArray(box) && box.length === 4) {
        if ((box[2] - box[0]) !== 0 && (box[3] - box[1]) !== 0) {
          return box;
        }
        warn(`Empty /${name} entry.`);
      }
      return null;
    }
  
    get mediaBox() {
      // Reset invalid media box to letter size.
      return shadow(this, 'mediaBox',
                    this._getBoundingBox('MediaBox') || LETTER_SIZE_MEDIABOX);
    }
  
    get cropBox() {
      // Reset invalid crop box to media box.
      return shadow(this, 'cropBox',
                    this._getBoundingBox('CropBox') || this.mediaBox);
    }
  
    get userUnit() {
      let obj = this.pageDict.get('UserUnit');
      if (!isNum(obj) || obj <= 0) {
        obj = DEFAULT_USER_UNIT;
      }
      return shadow(this, 'userUnit', obj);
    }
  
    get view() {
      // From the spec, 6th ed., p.963:
      // "The crop, bleed, trim, and art boxes should not ordinarily
      // extend beyond the boundaries of the media box. If they do, they are
      // effectively reduced to their intersection with the media box."
      const { cropBox, mediaBox, } = this;
      let view;
      if (cropBox === mediaBox || isArrayEqual(cropBox, mediaBox)) {
        view = mediaBox;
      } else {
        const box = Util.intersect(cropBox, mediaBox);
        if (box && ((box[2] - box[0]) !== 0 && (box[3] - box[1]) !== 0)) {
          view = box;
        } else {
          warn('Empty /CropBox and /MediaBox intersection.');
        }
      }
      return shadow(this, 'view', view || mediaBox);
    }
  
    get rotate() {
      let rotate = this._getInheritableProperty('Rotate') || 0;
  
      // Normalize rotation so it's a multiple of 90 and between 0 and 270.
      if (rotate % 90 !== 0) {
        rotate = 0;
      } else if (rotate >= 360) {
        rotate = rotate % 360;
      } else if (rotate < 0) {
        // The spec doesn't cover negatives. Assume it's counterclockwise
        // rotation. The following is the other implementation of modulo.
        rotate = ((rotate % 360) + 360) % 360;
      }
      return shadow(this, 'rotate', rotate);
    }
  
    getContentStream() {
      const content = this.content;
      let stream;
  
      if (Array.isArray(content)) {
        // Fetching the individual streams from the array.
        const xref = this.xref;
        const streams = [];
        for (const stream of content) {
          streams.push(xref.fetchIfRef(stream));
        }
        stream = new StreamsSequenceStream(streams);
      } else if (isStream(content)) {
        stream = content;
      } else {
        // Replace non-existent page content with empty content.
        stream = new NullStream();
      }
      return stream;
    }
  
    loadResources(keys) {
      if (!this.resourcesPromise) {
        // TODO: add async `_getInheritableProperty` and remove this.
        this.resourcesPromise = this.pdfManager.ensure(this, 'resources');
      }
      return this.resourcesPromise.then(() => {
        const objectLoader = new ObjectLoader(this.resources, keys, this.xref);
        return objectLoader.load();
      });
    }
  
    getOperatorList({ handler, sink, task, intent, renderInteractiveForms, }) {
      const contentStreamPromise = this.pdfManager.ensure(this,
                                                          'getContentStream');
      const resourcesPromise = this.loadResources([
        'ExtGState',
        'ColorSpace',
        'Pattern',
        'Shading',
        'XObject',
        'Font',
      ]);
  
      const partialEvaluator = new PartialEvaluator({
        xref: this.xref,
        handler,
        pageIndex: this.pageIndex,
        idFactory: this.idFactory,
        fontCache: this.fontCache,
        builtInCMapCache: this.builtInCMapCache,
        options: this.evaluatorOptions,
        pdfFunctionFactory: this.pdfFunctionFactory,
      });
  
      const dataPromises = Promise.all([contentStreamPromise, resourcesPromise]);
      const pageListPromise = dataPromises.then(([contentStream]) => {
        const opList = new OperatorList(intent, sink, this.pageIndex);
  
        handler.send('StartRenderPage', {
          transparency: partialEvaluator.hasBlendModes(this.resources),
          pageIndex: this.pageIndex,
          intent,
        });
  
        return partialEvaluator.getOperatorList({
          stream: contentStream,
          task,
          resources: this.resources,
          operatorList: opList,
        }).then(function() {
          return opList;
        });
      });
  
      // Fetch the page's annotations and add their operator lists to the
      // page's operator list to render them.
      return Promise.all([pageListPromise, this._parsedAnnotations]).then(
          function([pageOpList, annotations]) {
        if (annotations.length === 0) {
          pageOpList.flush(true);
          return { length: pageOpList.totalLength, };
        }
  
        // Collect the operator list promises for the annotations. Each promise
        // is resolved with the complete operator list for a single annotation.
        const opListPromises = [];
        for (const annotation of annotations) {
          if (isAnnotationRenderable(annotation, intent)) {
            opListPromises.push(annotation.getOperatorList(
              partialEvaluator, task, renderInteractiveForms));
          }
        }
  
        return Promise.all(opListPromises).then(function(opLists) {
          pageOpList.addOp(OPS.beginAnnotations, []);
          for (const opList of opLists) {
            pageOpList.addOpList(opList);
          }
          pageOpList.addOp(OPS.endAnnotations, []);
          pageOpList.flush(true);
          return { length: pageOpList.totalLength, };
        });
      });
    }
  
    extractTextContent({ handler, task, normalizeWhitespace, sink,
                         combineTextItems, }) {
      const contentStreamPromise = this.pdfManager.ensure(this,
                                                          'getContentStream');
      const resourcesPromise = this.loadResources([
        'ExtGState',
        'XObject',
        'Font',
      ]);
  
      const dataPromises = Promise.all([contentStreamPromise, resourcesPromise]);
      return dataPromises.then(([contentStream]) => {
        const partialEvaluator = new PartialEvaluator({
          xref: this.xref,
          handler,
          pageIndex: this.pageIndex,
          idFactory: this.idFactory,
          fontCache: this.fontCache,
          builtInCMapCache: this.builtInCMapCache,
          options: this.evaluatorOptions,
          pdfFunctionFactory: this.pdfFunctionFactory,
        });
  
        return partialEvaluator.getTextContent({
          stream: contentStream,
          task,
          resources: this.resources,
          normalizeWhitespace,
          combineTextItems,
          sink,
        });
      });
    }
  
    getAnnotationsData(intent) {
      return this._parsedAnnotations.then(function(annotations) {
        const annotationsData = [];
        for (let i = 0, ii = annotations.length; i < ii; i++) {
          if (!intent || isAnnotationRenderable(annotations[i], intent)) {
            annotationsData.push(annotations[i].data);
          }
        }
        return annotationsData;
      });
    }
  
    get annotations() {
      return shadow(this, 'annotations',
                    this._getInheritableProperty('Annots') || []);
    }
  
    get _parsedAnnotations() {
      const parsedAnnotations =
        this.pdfManager.ensure(this, 'annotations').then(() => {
          const annotationRefs = this.annotations;
          const annotationPromises = [];
          for (let i = 0, ii = annotationRefs.length; i < ii; i++) {
            annotationPromises.push(AnnotationFactory.create(
              this.xref, annotationRefs[i], this.pdfManager, this.idFactory));
          }
  
          return Promise.all(annotationPromises).then(function(annotations) {
            return annotations.filter(function isDefined(annotation) {
              return !!annotation;
            });
          }, function(reason) {
            warn(`_parsedAnnotations: "${reason}".`);
            return [];
          });
        });
  
      return shadow(this, '_parsedAnnotations', parsedAnnotations);
    }
  }
  
  const FINGERPRINT_FIRST_BYTES = 1024;
  const EMPTY_FINGERPRINT = '\x00\x00\x00\x00\x00\x00\x00' +
                            '\x00\x00\x00\x00\x00\x00\x00\x00\x00';
  
  function find(stream, needle, limit, backwards = false) {
    assert(limit > 0, 'The "limit" must be a positive integer.');
  
    const str = bytesToString(stream.peekBytes(limit));
  
    const index = backwards ? str.lastIndexOf(needle) : str.indexOf(needle);
    if (index === -1) {
      return false;
    }
    stream.pos += index;
    return true;
  }
  
  /**
   * The `PDFDocument` class holds all the data of the PDF file. There exists
   * one `PDFDocument` object on the main thread and one object for each worker.
   * If no worker support is enabled, two `PDFDocument` objects are created on
   * the main thread.
   */
  class PDFDocument {
    constructor(pdfManager, arg) {
      let stream;
      if (isStream(arg)) {
        stream = arg;
      } else if (isArrayBuffer(arg)) {
        stream = new Stream(arg);
      } else {
        throw new Error('PDFDocument: Unknown argument type');
      }
      if (stream.length <= 0) {
        throw new Error('PDFDocument: Stream must have data');
      }
  
      this.pdfManager = pdfManager;
      this.stream = stream;
      this.xref = new XRef(stream, pdfManager);
  
      this.pdfFunctionFactory = new PDFFunctionFactory({
        xref: this.xref,
        isEvalSupported: pdfManager.evaluatorOptions.isEvalSupported,
      });
      this._pagePromises = [];
    }
  
    parse(recoveryMode) {
      this.setup(recoveryMode);
  
      const version = this.catalog.catDict.get('Version');
      if (isName(version)) {
        this.pdfFormatVersion = version.name;
      }
  
      // Check if AcroForms are present in the document.
      try {
        this.acroForm = this.catalog.catDict.get('AcroForm');
        if (this.acroForm) {
          this.xfa = this.acroForm.get('XFA');
          const fields = this.acroForm.get('Fields');
          if ((!Array.isArray(fields) || fields.length === 0) && !this.xfa) {
            this.acroForm = null; // No fields and no XFA, so it's not a form.
          }
        }
      } catch (ex) {
        if (ex instanceof MissingDataException) {
          throw ex;
        }
        info('Cannot fetch AcroForm entry; assuming no AcroForms are present');
        this.acroForm = null;
      }
  
      // Check if a Collection dictionary is present in the document.
      try {
        const collection = this.catalog.catDict.get('Collection');
        if (isDict(collection) && collection.getKeys().length > 0) {
          this.collection = collection;
        }
      } catch (ex) {
        if (ex instanceof MissingDataException) {
          throw ex;
        }
        info('Cannot fetch Collection dictionary.');
      }
    }
  
    get linearization() {
      let linearization = null;
      try {
        linearization = Linearization.create(this.stream);
      } catch (err) {
        if (err instanceof MissingDataException) {
          throw err;
        }
        info(err);
      }
      return shadow(this, 'linearization', linearization);
    }
  
    get startXRef() {
      const stream = this.stream;
      let startXRef = 0;
  
      if (this.linearization) {
        // Find the end of the first object.
        stream.reset();
        if (find(stream, 'endobj', 1024)) {
          startXRef = stream.pos + 6;
        }
      } else {
        // Find `startxref` by checking backwards from the end of the file.
        const step = 1024;
        const startXRefLength = 'startxref'.length;
        let found = false, pos = stream.end;
  
        while (!found && pos > 0) {
          pos -= step - startXRefLength;
          if (pos < 0) {
            pos = 0;
          }
          stream.pos = pos;
          found = find(stream, 'startxref', step, true);
        }
  
        if (found) {
          stream.skip(9);
          let ch;
          do {
            ch = stream.getByte();
          } while (isSpace(ch));
          let str = '';
          while (ch >= 0x20 && ch <= 0x39) { // < '9'
            str += String.fromCharCode(ch);
            ch = stream.getByte();
          }
          startXRef = parseInt(str, 10);
          if (isNaN(startXRef)) {
            startXRef = 0;
          }
        }
      }
      return shadow(this, 'startXRef', startXRef);
    }
  
    // Find the header, get the PDF format version and setup the
    // stream to start from the header.
    checkHeader() {
      const stream = this.stream;
      stream.reset();
  
      if (!find(stream, '%PDF-', 1024)) {
        // May not be a PDF file, but don't throw an error and let
        // parsing continue.
        return;
      }
      stream.moveStart();
  
      // Read the PDF format version.
      const MAX_PDF_VERSION_LENGTH = 12;
      let version = '', ch;
      while ((ch = stream.getByte()) > 0x20) { // Space
        if (version.length >= MAX_PDF_VERSION_LENGTH) {
          break;
        }
        version += String.fromCharCode(ch);
      }
      if (!this.pdfFormatVersion) {
        // Remove the "%PDF-" prefix.
        this.pdfFormatVersion = version.substring(5);
      }
    }
  
    parseStartXRef() {
      this.xref.setStartXRef(this.startXRef);
    }
  
    setup(recoveryMode) {
      this.xref.parse(recoveryMode);
      this.catalog = new Catalog(this.pdfManager, this.xref);
    }
  
    get numPages() {
      const linearization = this.linearization;
      const num = linearization ? linearization.numPages : this.catalog.numPages;
      return shadow(this, 'numPages', num);
    }
  
    get documentInfo() {
      const DocumentInfoValidators = {
        Title: isString,
        Author: isString,
        Subject: isString,
        Keywords: isString,
        Creator: isString,
        Producer: isString,
        CreationDate: isString,
        ModDate: isString,
        Trapped: isName,
      };
  
      const docInfo = {
        PDFFormatVersion: this.pdfFormatVersion,
        IsLinearized: !!this.linearization,
        IsAcroFormPresent: !!this.acroForm,
        IsXFAPresent: !!this.xfa,
        IsCollectionPresent: !!this.collection,
      };
  
      let infoDict;
      try {
        infoDict = this.xref.trailer.get('Info');
      } catch (err) {
        if (err instanceof MissingDataException) {
          throw err;
        }
        info('The document information dictionary is invalid.');
      }
  
      if (isDict(infoDict)) {
        // Fill the document info with valid entries from the specification,
        // as well as any existing well-formed custom entries.
        for (const key of infoDict.getKeys()) {
          const value = infoDict.get(key);
  
          if (DocumentInfoValidators[key]) {
            // Make sure the (standard) value conforms to the specification.
            if (DocumentInfoValidators[key](value)) {
              docInfo[key] = (typeof value !== 'string' ?
                              value : stringToPDFString(value));
            } else {
              info(`Bad value in document info for "${key}".`);
            }
          } else if (typeof key === 'string') {
            // For custom values, only accept white-listed types to prevent
            // errors that would occur when trying to send non-serializable
            // objects to the main-thread (for example `Dict` or `Stream`).
            let customValue;
            if (isString(value)) {
              customValue = stringToPDFString(value);
            } else if (isName(value) || isNum(value) || isBool(value)) {
              customValue = value;
            } else {
              info(`Unsupported value in document info for (custom) "${key}".`);
              continue;
            }
  
            if (!docInfo['Custom']) {
              docInfo['Custom'] = Object.create(null);
            }
            docInfo['Custom'][key] = customValue;
          }
        }
      }
      return shadow(this, 'documentInfo', docInfo);
    }
  
    get fingerprint() {
      let hash;
      const idArray = this.xref.trailer.get('ID');
      if (Array.isArray(idArray) && idArray[0] && isString(idArray[0]) &&
          idArray[0] !== EMPTY_FINGERPRINT) {
        hash = stringToBytes(idArray[0]);
      } else {
        hash = calculateMD5(this.stream.getByteRange(0, FINGERPRINT_FIRST_BYTES),
                            0, FINGERPRINT_FIRST_BYTES);
      }
  
      const fingerprintBuf = [];
      for (let i = 0, ii = hash.length; i < ii; i++) {
        const hex = hash[i].toString(16);
        fingerprintBuf.push(hex.padStart(2, '0'));
      }
      return shadow(this, 'fingerprint', fingerprintBuf.join(''));
    }
  
    _getLinearizationPage(pageIndex) {
      const { catalog, linearization, } = this;
      assert(linearization && linearization.pageFirst === pageIndex);
  
      const ref = Ref.get(linearization.objectNumberFirst, 0);
      return this.xref.fetchAsync(ref).then((obj) => {
        // Ensure that the object that was found is actually a Page dictionary.
        if (isDict(obj, 'Page') ||
            (isDict(obj) && !obj.has('Type') && obj.has('Contents'))) {
          if (ref && !catalog.pageKidsCountCache.has(ref)) {
            catalog.pageKidsCountCache.put(ref, 1); // Cache the Page reference.
          }
          return [obj, ref];
        }
        throw new FormatError('The Linearization dictionary doesn\'t point ' +
                              'to a valid Page dictionary.');
      }).catch((reason) => {
        info(reason);
        return catalog.getPageDict(pageIndex);
      });
    }
  
    getPage(pageIndex) {
      if (this._pagePromises[pageIndex] !== undefined) {
        return this._pagePromises[pageIndex];
      }
      const { catalog, linearization, } = this;
  
      const promise = (linearization && linearization.pageFirst === pageIndex) ?
        this._getLinearizationPage(pageIndex) : catalog.getPageDict(pageIndex);
  
      return this._pagePromises[pageIndex] = promise.then(([pageDict, ref]) => {
        return new Page({
          pdfManager: this.pdfManager,
          xref: this.xref,
          pageIndex,
          pageDict,
          ref,
          fontCache: catalog.fontCache,
          builtInCMapCache: catalog.builtInCMapCache,
          pdfFunctionFactory: this.pdfFunctionFactory,
        });
      });
    }
  
    checkFirstPage() {
      return this.getPage(0).catch((reason) => {
        if (reason instanceof XRefEntryException) {
          // Clear out the various caches to ensure that we haven't stored any
          // inconsistent and/or incorrect state, since that could easily break
          // subsequent `this.getPage` calls.
          this._pagePromises.length = 0;
          this.cleanup();
  
          throw new XRefParseException();
        }
      });
    }
  
    fontFallback(id, handler) {
      return this.catalog.fontFallback(id, handler);
    }
  
    cleanup() {
      return this.catalog.cleanup();
    }
  }
  
  export {
    Page,
    PDFDocument,
  };
  