pdfjs.parser.js

/* Copyright 2015 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.
 */
/* globals global */

"use strict";

(function(root, factory) {
  //if (typeof define === 'function' && define.amd) {
  //  define('pdfjs/shared/global', ['exports'], factory);
  // } else if (typeof exports !== 'undefined') {
  //   factory(exports);
  //} else {
  factory((root.pdfjsSharedGlobal = {}));
  //}
})(window, function(exports) {
  var globalScope =
    typeof window !== "undefined"
      ? window
      : typeof global !== "undefined"
      ? global
      : typeof self !== "undefined"
      ? self
      : this;

  var isWorker = typeof window === "undefined";

  // The global PDFJS object exposes the API
  // In production, it will be declared outside a global wrapper
  // In development, it will be declared here
  if (!globalScope.PDFJS) {
    globalScope.PDFJS = {};
  }

  globalScope.PDFJS.pdfBug = false;

  exports.globalScope = globalScope;
  exports.isWorker = isWorker;
  exports.PDFJS = globalScope.PDFJS;
});

/* 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.
 */
/* globals MozBlobBuilder, URL */

("use strict");

(function(root, factory) {
  //if (typeof define === 'function' && define.amd) {
  //  define('pdfjs/shared/util', ['exports', 'pdfjs/shared/global'], factory);
  // } else if (typeof exports !== 'undefined') {
  //   factory(exports, require('./global.js'));
  //} else {
  factory((root.pdfjsSharedUtil = {}), root.pdfjsSharedGlobal);
  //}
})(window, function(exports, sharedGlobal) {
  var PDFJS = sharedGlobal.PDFJS;
  var globalScope = sharedGlobal.globalScope;

  var FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];

  var TextRenderingMode = {
    FILL: 0,
    STROKE: 1,
    FILL_STROKE: 2,
    INVISIBLE: 3,
    FILL_ADD_TO_PATH: 4,
    STROKE_ADD_TO_PATH: 5,
    FILL_STROKE_ADD_TO_PATH: 6,
    ADD_TO_PATH: 7,
    FILL_STROKE_MASK: 3,
    ADD_TO_PATH_FLAG: 4
  };

  var ImageKind = {
    GRAYSCALE_1BPP: 1,
    RGB_24BPP: 2,
    RGBA_32BPP: 3
  };

  var AnnotationType = {
    TEXT: 1,
    LINK: 2,
    FREETEXT: 3,
    LINE: 4,
    SQUARE: 5,
    CIRCLE: 6,
    POLYGON: 7,
    POLYLINE: 8,
    HIGHLIGHT: 9,
    UNDERLINE: 10,
    SQUIGGLY: 11,
    STRIKEOUT: 12,
    STAMP: 13,
    CARET: 14,
    INK: 15,
    POPUP: 16,
    FILEATTACHMENT: 17,
    SOUND: 18,
    MOVIE: 19,
    WIDGET: 20,
    SCREEN: 21,
    PRINTERMARK: 22,
    TRAPNET: 23,
    WATERMARK: 24,
    THREED: 25,
    REDACT: 26
  };

  var AnnotationFlag = {
    INVISIBLE: 0x01,
    HIDDEN: 0x02,
    PRINT: 0x04,
    NOZOOM: 0x08,
    NOROTATE: 0x10,
    NOVIEW: 0x20,
    READONLY: 0x40,
    LOCKED: 0x80,
    TOGGLENOVIEW: 0x100,
    LOCKEDCONTENTS: 0x200
  };

  var AnnotationBorderStyleType = {
    SOLID: 1,
    DASHED: 2,
    BEVELED: 3,
    INSET: 4,
    UNDERLINE: 5
  };

  var StreamType = {
    UNKNOWN: 0,
    FLATE: 1,
    LZW: 2,
    DCT: 3,
    JPX: 4,
    JBIG: 5,
    A85: 6,
    AHX: 7,
    CCF: 8,
    RL: 9
  };

  var FontType = {
    UNKNOWN: 0,
    TYPE1: 1,
    TYPE1C: 2,
    CIDFONTTYPE0: 3,
    CIDFONTTYPE0C: 4,
    TRUETYPE: 5,
    CIDFONTTYPE2: 6,
    TYPE3: 7,
    OPENTYPE: 8,
    TYPE0: 9,
    MMTYPE1: 10
  };

  PDFJS.VERBOSITY_LEVELS = {
    errors: 0,
    warnings: 1,
    infos: 5
  };

  // All the possible operations for an operator list.
  var OPS = (PDFJS.OPS = {
    // Intentionally start from 1 so it is easy to spot bad operators that will be
    // 0's.
    dependency: 1,
    setLineWidth: 2,
    setLineCap: 3,
    setLineJoin: 4,
    setMiterLimit: 5,
    setDash: 6,
    setRenderingIntent: 7,
    setFlatness: 8,
    setGState: 9,
    save: 10,
    restore: 11,
    transform: 12,
    moveTo: 13,
    lineTo: 14,
    curveTo: 15,
    curveTo2: 16,
    curveTo3: 17,
    closePath: 18,
    rectangle: 19,
    stroke: 20,
    closeStroke: 21,
    fill: 22,
    eoFill: 23,
    fillStroke: 24,
    eoFillStroke: 25,
    closeFillStroke: 26,
    closeEOFillStroke: 27,
    endPath: 28,
    clip: 29,
    eoClip: 30,
    beginText: 31,
    endText: 32,
    setCharSpacing: 33,
    setWordSpacing: 34,
    setHScale: 35,
    setLeading: 36,
    setFont: 37,
    setTextRenderingMode: 38,
    setTextRise: 39,
    moveText: 40,
    setLeadingMoveText: 41,
    setTextMatrix: 42,
    nextLine: 43,
    showText: 44,
    showSpacedText: 45,
    nextLineShowText: 46,
    nextLineSetSpacingShowText: 47,
    setCharWidth: 48,
    setCharWidthAndBounds: 49,
    setStrokeColorSpace: 50,
    setFillColorSpace: 51,
    setStrokeColor: 52,
    setStrokeColorN: 53,
    setFillColor: 54,
    setFillColorN: 55,
    setStrokeGray: 56,
    setFillGray: 57,
    setStrokeRGBColor: 58,
    setFillRGBColor: 59,
    setStrokeCMYKColor: 60,
    setFillCMYKColor: 61,
    shadingFill: 62,
    beginInlineImage: 63,
    beginImageData: 64,
    endInlineImage: 65,
    paintXObject: 66,
    markPoint: 67,
    markPointProps: 68,
    beginMarkedContent: 69,
    beginMarkedContentProps: 70,
    endMarkedContent: 71,
    beginCompat: 72,
    endCompat: 73,
    paintFormXObjectBegin: 74,
    paintFormXObjectEnd: 75,
    beginGroup: 76,
    endGroup: 77,
    beginAnnotations: 78,
    endAnnotations: 79,
    beginAnnotation: 80,
    endAnnotation: 81,
    paintJpegXObject: 82,
    paintImageMaskXObject: 83,
    paintImageMaskXObjectGroup: 84,
    paintImageXObject: 85,
    paintInlineImageXObject: 86,
    paintInlineImageXObjectGroup: 87,
    paintImageXObjectRepeat: 88,
    paintImageMaskXObjectRepeat: 89,
    paintSolidColorImageMask: 90,
    constructPath: 91
  });

  // A notice for devs. These are good for things that are helpful to devs, such
  // as warning that Workers were disabled, which is important to devs but not
  // end users.
  function info(msg) {
    if (PDFJS.verbosity >= PDFJS.VERBOSITY_LEVELS.infos) {
      console.log("Info: " + msg);
    }
  }

  // Non-fatal warnings.
  function warn(msg) {
    if (PDFJS.verbosity >= PDFJS.VERBOSITY_LEVELS.warnings) {
      console.log("Warning: " + msg);
    }
  }

  // Deprecated API function -- treated as warnings.
  function deprecated(details) {
    warn("Deprecated API usage: " + details);
  }

  // Fatal errors that should trigger the fallback UI and halt execution by
  // throwing an exception.
  function error(msg) {
    if (PDFJS.verbosity >= PDFJS.VERBOSITY_LEVELS.errors) {
      console.log("Error: " + msg);
      console.log(backtrace());
    }
    throw new Error(msg);
  }

  function backtrace() {
    try {
      throw new Error();
    } catch (e) {
      return e.stack
        ? e.stack
            .split("\n")
            .slice(2)
            .join("\n")
        : "";
    }
  }

  function assert(cond, msg) {
    if (!cond) {
      error(msg);
    }
  }

  var UNSUPPORTED_FEATURES = (PDFJS.UNSUPPORTED_FEATURES = {
    unknown: "unknown",
    forms: "forms",
    javaScript: "javaScript",
    smask: "smask",
    shadingPattern: "shadingPattern",
    font: "font"
  });

  // Combines two URLs. The baseUrl shall be absolute URL. If the url is an
  // absolute URL, it will be returned as is.
  function combineUrl(baseUrl, url) {
    if (!url) {
      return baseUrl;
    }
    if (/^[a-z][a-z0-9+\-.]*:/i.test(url)) {
      return url;
    }
    var i;
    if (url.charAt(0) === "/") {
      // absolute path
      i = baseUrl.indexOf("://");
      if (url.charAt(1) === "/") {
        ++i;
      } else {
        i = baseUrl.indexOf("/", i + 3);
      }
      return baseUrl.substring(0, i) + url;
    } else {
      // relative path
      var pathLength = baseUrl.length;
      i = baseUrl.lastIndexOf("#");
      pathLength = i >= 0 ? i : pathLength;
      i = baseUrl.lastIndexOf("?", pathLength);
      pathLength = i >= 0 ? i : pathLength;
      var prefixLength = baseUrl.lastIndexOf("/", pathLength);
      return baseUrl.substring(0, prefixLength + 1) + url;
    }
  }

  // Validates if URL is safe and allowed, e.g. to avoid XSS.
  function isValidUrl(url, allowRelative) {
    if (!url) {
      return false;
    }
    // RFC 3986 (http://tools.ietf.org/html/rfc3986#section-3.1)
    // scheme = ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
    var protocol = /^[a-z][a-z0-9+\-.]*(?=:)/i.exec(url);
    if (!protocol) {
      return allowRelative;
    }
    protocol = protocol[0].toLowerCase();
    switch (protocol) {
      case "http":
      case "https":
      case "ftp":
      case "mailto":
      case "tel":
        return true;
      default:
        return false;
    }
  }
  PDFJS.isValidUrl = isValidUrl;

  function shadow(obj, prop, value) {
    Object.defineProperty(obj, prop, {
      value: value,
      enumerable: true,
      configurable: true,
      writable: false
    });
    return value;
  }
  PDFJS.shadow = shadow;

  var LinkTarget = (PDFJS.LinkTarget = {
    NONE: 0, // Default value.
    SELF: 1,
    BLANK: 2,
    PARENT: 3,
    TOP: 4
  });
  var LinkTargetStringMap = ["", "_self", "_blank", "_parent", "_top"];

  function isExternalLinkTargetSet() {
    //#if !MOZCENTRAL
    if (PDFJS.openExternalLinksInNewWindow) {
      deprecated(
        "PDFJS.openExternalLinksInNewWindow, please use " +
          '"PDFJS.externalLinkTarget = PDFJS.LinkTarget.BLANK" instead.'
      );
      if (PDFJS.externalLinkTarget === LinkTarget.NONE) {
        PDFJS.externalLinkTarget = LinkTarget.BLANK;
      }
      // Reset the deprecated parameter, to suppress further warnings.
      PDFJS.openExternalLinksInNewWindow = false;
    }
    //#endif
    switch (PDFJS.externalLinkTarget) {
      case LinkTarget.NONE:
        return false;
      case LinkTarget.SELF:
      case LinkTarget.BLANK:
      case LinkTarget.PARENT:
      case LinkTarget.TOP:
        return true;
    }
    warn("PDFJS.externalLinkTarget is invalid: " + PDFJS.externalLinkTarget);
    // Reset the external link target, to suppress further warnings.
    PDFJS.externalLinkTarget = LinkTarget.NONE;
    return false;
  }
  PDFJS.isExternalLinkTargetSet = isExternalLinkTargetSet;

  var PasswordResponses = (PDFJS.PasswordResponses = {
    NEED_PASSWORD: 1,
    INCORRECT_PASSWORD: 2
  });

  var PasswordException = (function PasswordExceptionClosure() {
    function PasswordException(msg, code) {
      this.name = "PasswordException";
      this.message = msg;
      this.code = code;
    }

    PasswordException.prototype = new Error();
    PasswordException.constructor = PasswordException;

    return PasswordException;
  })();
  PDFJS.PasswordException = PasswordException;

  var UnknownErrorException = (function UnknownErrorExceptionClosure() {
    function UnknownErrorException(msg, details) {
      this.name = "UnknownErrorException";
      this.message = msg;
      this.details = details;
    }

    UnknownErrorException.prototype = new Error();
    UnknownErrorException.constructor = UnknownErrorException;

    return UnknownErrorException;
  })();
  PDFJS.UnknownErrorException = UnknownErrorException;

  var InvalidPDFException = (function InvalidPDFExceptionClosure() {
    function InvalidPDFException(msg) {
      this.name = "InvalidPDFException";
      this.message = msg;
    }

    InvalidPDFException.prototype = new Error();
    InvalidPDFException.constructor = InvalidPDFException;

    return InvalidPDFException;
  })();
  PDFJS.InvalidPDFException = InvalidPDFException;

  var MissingPDFException = (function MissingPDFExceptionClosure() {
    function MissingPDFException(msg) {
      this.name = "MissingPDFException";
      this.message = msg;
    }

    MissingPDFException.prototype = new Error();
    MissingPDFException.constructor = MissingPDFException;

    return MissingPDFException;
  })();
  PDFJS.MissingPDFException = MissingPDFException;

  var UnexpectedResponseException = (function UnexpectedResponseExceptionClosure() {
    function UnexpectedResponseException(msg, status) {
      this.name = "UnexpectedResponseException";
      this.message = msg;
      this.status = status;
    }

    UnexpectedResponseException.prototype = new Error();
    UnexpectedResponseException.constructor = UnexpectedResponseException;

    return UnexpectedResponseException;
  })();
  PDFJS.UnexpectedResponseException = UnexpectedResponseException;

  var NotImplementedException = (function NotImplementedExceptionClosure() {
    function NotImplementedException(msg) {
      this.message = msg;
    }

    NotImplementedException.prototype = new Error();
    NotImplementedException.prototype.name = "NotImplementedException";
    NotImplementedException.constructor = NotImplementedException;

    return NotImplementedException;
  })();

  var MissingDataException = (function MissingDataExceptionClosure() {
    function MissingDataException(begin, end) {
      this.begin = begin;
      this.end = end;
      this.message = "Missing data [" + begin + ", " + end + ")";
    }

    MissingDataException.prototype = new Error();
    MissingDataException.prototype.name = "MissingDataException";
    MissingDataException.constructor = MissingDataException;

    return MissingDataException;
  })();

  var XRefParseException = (function XRefParseExceptionClosure() {
    function XRefParseException(msg) {
      this.message = msg;
    }

    XRefParseException.prototype = new Error();
    XRefParseException.prototype.name = "XRefParseException";
    XRefParseException.constructor = XRefParseException;

    return XRefParseException;
  })();

  function bytesToString(bytes) {
    assert(
      bytes !== null && typeof bytes === "object" && bytes.length !== undefined,
      "Invalid argument for bytesToString"
    );
    var length = bytes.length;
    var MAX_ARGUMENT_COUNT = 8192;
    if (length < MAX_ARGUMENT_COUNT) {
      return String.fromCharCode.apply(null, bytes);
    }
    var strBuf = [];
    for (var i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
      var chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
      var chunk = bytes.subarray(i, chunkEnd);
      strBuf.push(String.fromCharCode.apply(null, chunk));
    }
    return strBuf.join("");
  }

  function stringToBytes(str) {
    assert(typeof str === "string", "Invalid argument for stringToBytes");
    var length = str.length;
    var bytes = new Uint8Array(length);
    for (var i = 0; i < length; ++i) {
      bytes[i] = str.charCodeAt(i) & 0xff;
    }
    return bytes;
  }

  function string32(value) {
    return String.fromCharCode(
      (value >> 24) & 0xff,
      (value >> 16) & 0xff,
      (value >> 8) & 0xff,
      value & 0xff
    );
  }

  function log2(x) {
    var n = 1,
      i = 0;
    while (x > n) {
      n <<= 1;
      i++;
    }
    return i;
  }

  function readInt8(data, start) {
    return (data[start] << 24) >> 24;
  }

  function readUint16(data, offset) {
    return (data[offset] << 8) | data[offset + 1];
  }

  function readUint32(data, offset) {
    return (
      ((data[offset] << 24) |
        (data[offset + 1] << 16) |
        (data[offset + 2] << 8) |
        data[offset + 3]) >>>
      0
    );
  }

  // Lazy test the endianness of the platform
  // NOTE: This will be 'true' for simulated TypedArrays
  function isLittleEndian() {
    var buffer8 = new Uint8Array(2);
    buffer8[0] = 1;
    var buffer16 = new Uint16Array(buffer8.buffer);
    return buffer16[0] === 1;
  }

  Object.defineProperty(PDFJS, "isLittleEndian", {
    configurable: true,
    get: function PDFJS_isLittleEndian() {
      return shadow(PDFJS, "isLittleEndian", isLittleEndian());
    }
  });

  //#if !(FIREFOX || MOZCENTRAL || CHROME)
  //// Lazy test if the userAgent support CanvasTypedArrays
  function hasCanvasTypedArrays() {
    var canvas = document.createElement("canvas");
    canvas.width = canvas.height = 1;
    var ctx = canvas.getContext("2d");
    var imageData = ctx.createImageData(1, 1);
    return typeof imageData.data.buffer !== "undefined";
  }

  Object.defineProperty(PDFJS, "hasCanvasTypedArrays", {
    configurable: true,
    get: function PDFJS_hasCanvasTypedArrays() {
      return shadow(PDFJS, "hasCanvasTypedArrays", hasCanvasTypedArrays());
    }
  });

  var Uint32ArrayView = (function Uint32ArrayViewClosure() {
    function Uint32ArrayView(buffer, length) {
      this.buffer = buffer;
      this.byteLength = buffer.length;
      this.length = length === undefined ? this.byteLength >> 2 : length;
      ensureUint32ArrayViewProps(this.length);
    }
    Uint32ArrayView.prototype = Object.create(null);

    var uint32ArrayViewSetters = 0;
    function createUint32ArrayProp(index) {
      return {
        get: function() {
          var buffer = this.buffer,
            offset = index << 2;
          return (
            (buffer[offset] |
              (buffer[offset + 1] << 8) |
              (buffer[offset + 2] << 16) |
              (buffer[offset + 3] << 24)) >>>
            0
          );
        },
        set: function(value) {
          var buffer = this.buffer,
            offset = index << 2;
          buffer[offset] = value & 255;
          buffer[offset + 1] = (value >> 8) & 255;
          buffer[offset + 2] = (value >> 16) & 255;
          buffer[offset + 3] = (value >>> 24) & 255;
        }
      };
    }

    function ensureUint32ArrayViewProps(length) {
      while (uint32ArrayViewSetters < length) {
        Object.defineProperty(
          Uint32ArrayView.prototype,
          uint32ArrayViewSetters,
          createUint32ArrayProp(uint32ArrayViewSetters)
        );
        uint32ArrayViewSetters++;
      }
    }

    return Uint32ArrayView;
  })();

  exports.Uint32ArrayView = Uint32ArrayView;
  //#else
  //PDFJS.hasCanvasTypedArrays = true;
  //#endif

  var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];

  var Util = (PDFJS.Util = (function UtilClosure() {
    function Util() {}

    var rgbBuf = ["rgb(", 0, ",", 0, ",", 0, ")"];

    // makeCssRgb() can be called thousands of times. Using |rgbBuf| avoids
    // creating many intermediate strings.
    Util.makeCssRgb = function Util_makeCssRgb(r, g, b) {
      rgbBuf[1] = r;
      rgbBuf[3] = g;
      rgbBuf[5] = b;
      return rgbBuf.join("");
    };

    // Concatenates two transformation matrices together and returns the result.
    Util.transform = function Util_transform(m1, m2) {
      return [
        m1[0] * m2[0] + m1[2] * m2[1],
        m1[1] * m2[0] + m1[3] * m2[1],
        m1[0] * m2[2] + m1[2] * m2[3],
        m1[1] * m2[2] + m1[3] * m2[3],
        m1[0] * m2[4] + m1[2] * m2[5] + m1[4],
        m1[1] * m2[4] + m1[3] * m2[5] + m1[5]
      ];
    };

    // For 2d affine transforms
    Util.applyTransform = function Util_applyTransform(p, m) {
      var xt = p[0] * m[0] + p[1] * m[2] + m[4];
      var yt = p[0] * m[1] + p[1] * m[3] + m[5];
      return [xt, yt];
    };

    Util.applyInverseTransform = function Util_applyInverseTransform(p, m) {
      var d = m[0] * m[3] - m[1] * m[2];
      var xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
      var yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
      return [xt, yt];
    };

    // Applies the transform to the rectangle and finds the minimum axially
    // aligned bounding box.
    Util.getAxialAlignedBoundingBox = function Util_getAxialAlignedBoundingBox(
      r,
      m
    ) {
      var p1 = Util.applyTransform(r, m);
      var p2 = Util.applyTransform(r.slice(2, 4), m);
      var p3 = Util.applyTransform([r[0], r[3]], m);
      var p4 = Util.applyTransform([r[2], r[1]], m);
      return [
        Math.min(p1[0], p2[0], p3[0], p4[0]),
        Math.min(p1[1], p2[1], p3[1], p4[1]),
        Math.max(p1[0], p2[0], p3[0], p4[0]),
        Math.max(p1[1], p2[1], p3[1], p4[1])
      ];
    };

    Util.inverseTransform = function Util_inverseTransform(m) {
      var d = m[0] * m[3] - m[1] * m[2];
      return [
        m[3] / d,
        -m[1] / d,
        -m[2] / d,
        m[0] / d,
        (m[2] * m[5] - m[4] * m[3]) / d,
        (m[4] * m[1] - m[5] * m[0]) / d
      ];
    };

    // Apply a generic 3d matrix M on a 3-vector v:
    //   | a b c |   | X |
    //   | d e f | x | Y |
    //   | g h i |   | Z |
    // M is assumed to be serialized as [a,b,c,d,e,f,g,h,i],
    // with v as [X,Y,Z]
    Util.apply3dTransform = function Util_apply3dTransform(m, v) {
      return [
        m[0] * v[0] + m[1] * v[1] + m[2] * v[2],
        m[3] * v[0] + m[4] * v[1] + m[5] * v[2],
        m[6] * v[0] + m[7] * v[1] + m[8] * v[2]
      ];
    };

    // This calculation uses Singular Value Decomposition.
    // The SVD can be represented with formula A = USV. We are interested in the
    // matrix S here because it represents the scale values.
    Util.singularValueDecompose2dScale = function Util_singularValueDecompose2dScale(
      m
    ) {
      var transpose = [m[0], m[2], m[1], m[3]];

      // Multiply matrix m with its transpose.
      var a = m[0] * transpose[0] + m[1] * transpose[2];
      var b = m[0] * transpose[1] + m[1] * transpose[3];
      var c = m[2] * transpose[0] + m[3] * transpose[2];
      var d = m[2] * transpose[1] + m[3] * transpose[3];

      // Solve the second degree polynomial to get roots.
      var first = (a + d) / 2;
      var second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;
      var sx = first + second || 1;
      var sy = first - second || 1;

      // Scale values are the square roots of the eigenvalues.
      return [Math.sqrt(sx), Math.sqrt(sy)];
    };

    // Normalize rectangle rect=[x1, y1, x2, y2] so that (x1,y1) < (x2,y2)
    // For coordinate systems whose origin lies in the bottom-left, this
    // means normalization to (BL,TR) ordering. For systems with origin in the
    // top-left, this means (TL,BR) ordering.
    Util.normalizeRect = function Util_normalizeRect(rect) {
      var r = rect.slice(0); // clone rect
      if (rect[0] > rect[2]) {
        r[0] = rect[2];
        r[2] = rect[0];
      }
      if (rect[1] > rect[3]) {
        r[1] = rect[3];
        r[3] = rect[1];
      }
      return r;
    };

    // Returns a rectangle [x1, y1, x2, y2] corresponding to the
    // intersection of rect1 and rect2. If no intersection, returns 'false'
    // The rectangle coordinates of rect1, rect2 should be [x1, y1, x2, y2]
    Util.intersect = function Util_intersect(rect1, rect2) {
      function compare(a, b) {
        return a - b;
      }

      // Order points along the axes
      var orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare),
        orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare),
        result = [];

      rect1 = Util.normalizeRect(rect1);
      rect2 = Util.normalizeRect(rect2);

      // X: first and second points belong to different rectangles?
      if (
        (orderedX[0] === rect1[0] && orderedX[1] === rect2[0]) ||
        (orderedX[0] === rect2[0] && orderedX[1] === rect1[0])
      ) {
        // Intersection must be between second and third points
        result[0] = orderedX[1];
        result[2] = orderedX[2];
      } else {
        return false;
      }

      // Y: first and second points belong to different rectangles?
      if (
        (orderedY[0] === rect1[1] && orderedY[1] === rect2[1]) ||
        (orderedY[0] === rect2[1] && orderedY[1] === rect1[1])
      ) {
        // Intersection must be between second and third points
        result[1] = orderedY[1];
        result[3] = orderedY[2];
      } else {
        return false;
      }

      return result;
    };

    Util.sign = function Util_sign(num) {
      return num < 0 ? -1 : 1;
    };

    Util.appendToArray = function Util_appendToArray(arr1, arr2) {
      Array.prototype.push.apply(arr1, arr2);
    };

    Util.prependToArray = function Util_prependToArray(arr1, arr2) {
      Array.prototype.unshift.apply(arr1, arr2);
    };

    Util.extendObj = function extendObj(obj1, obj2) {
      for (var key in obj2) {
        obj1[key] = obj2[key];
      }
    };

    Util.getInheritableProperty = function Util_getInheritableProperty(
      dict,
      name
    ) {
      while (dict && !dict.has(name)) {
        dict = dict.get("Parent");
      }
      if (!dict) {
        return null;
      }
      return dict.get(name);
    };

    Util.inherit = function Util_inherit(sub, base, prototype) {
      sub.prototype = Object.create(base.prototype);
      sub.prototype.constructor = sub;
      for (var prop in prototype) {
        sub.prototype[prop] = prototype[prop];
      }
    };

    Util.loadScript = function Util_loadScript(src, callback) {
      var script = document.createElement("script");
      var loaded = false;
      script.setAttribute("src", src);
      if (callback) {
        script.onload = function() {
          if (!loaded) {
            callback();
          }
          loaded = true;
        };
      }
      document.getElementsByTagName("head")[0].appendChild(script);
    };

    return Util;
  })());

  /**
   * PDF page viewport created based on scale, rotation and offset.
   * @class
   * @alias PDFJS.PageViewport
   */
  var PageViewport = (PDFJS.PageViewport = (function PageViewportClosure() {
    /**
     * @constructor
     * @private
     * @param viewBox {Array} xMin, yMin, xMax and yMax coordinates.
     * @param scale {number} scale of the viewport.
     * @param rotation {number} rotations of the viewport in degrees.
     * @param offsetX {number} offset X
     * @param offsetY {number} offset Y
     * @param dontFlip {boolean} if true, axis Y will not be flipped.
     */
    function PageViewport(
      viewBox,
      scale,
      rotation,
      offsetX,
      offsetY,
      dontFlip
    ) {
      this.viewBox = viewBox;
      this.scale = scale;
      this.rotation = rotation;
      this.offsetX = offsetX;
      this.offsetY = offsetY;

      // creating transform to convert pdf coordinate system to the normal
      // canvas like coordinates taking in account scale and rotation
      var centerX = (viewBox[2] + viewBox[0]) / 2;
      var centerY = (viewBox[3] + viewBox[1]) / 2;
      var rotateA, rotateB, rotateC, rotateD;
      rotation = rotation % 360;
      rotation = rotation < 0 ? rotation + 360 : rotation;
      switch (rotation) {
        case 180:
          rotateA = -1;
          rotateB = 0;
          rotateC = 0;
          rotateD = 1;
          break;
        case 90:
          rotateA = 0;
          rotateB = 1;
          rotateC = 1;
          rotateD = 0;
          break;
        case 270:
          rotateA = 0;
          rotateB = -1;
          rotateC = -1;
          rotateD = 0;
          break;
        //case 0:
        default:
          rotateA = 1;
          rotateB = 0;
          rotateC = 0;
          rotateD = -1;