https://lism.catholic.edu.au/theme/_blueprint/js/pdf/build/pdf.js

615  }
616}
617
618var Uint32ArrayView = (function Uint32ArrayViewClosure() {
619
620  function Uint32ArrayView(buffer, length) {
621    this.buffer = buffer;
622    this.byteLength = buffer.length;
623    this.length = length === undefined ? (this.byteLength >> 2) : length;
624    ensureUint32ArrayViewProps(this.length);
625  }
626  Uint32ArrayView.prototype = Object.create(null);
627
628  var uint32ArrayViewSetters = 0;
629  function createUint32ArrayProp(index) {
630    return {
631      get: function () {
632        var buffer = this.buffer, offset = index << 2;
633        return (buffer[offset] | (buffer[offset + 1] << 8) |
634          (buffer[offset + 2] << 16) | (buffer[offset + 3] << 24)) >>> 0;
635      },
636      set: function (value) {
637        var buffer = this.buffer, offset = index << 2;
638        buffer[offset] = value & 255;
639        buffer[offset + 1] = (value >> 8) & 255;
640        buffer[offset + 2] = (value >> 16) & 255;
641        buffer[offset + 3] = (value >>> 24) & 255;
642      }
643    };
644  }
645
646  function ensureUint32ArrayViewProps(length) {
647    while (uint32ArrayViewSetters < length) {
648      Object.defineProperty(Uint32ArrayView.prototype,
649        uint32ArrayViewSetters,
650        createUint32ArrayProp(uint32ArrayViewSetters));
651      uint32ArrayViewSetters++;
652    }
653  }
654
655  return Uint32ArrayView;
656})();
657
658exports.Uint32ArrayView = Uint32ArrayView;
659
660var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
661
662var Util = (function UtilClosure() {
663  function Util() {}
664
665  var rgbBuf = ['rgb(', 0, ',', 0, ',', 0, ')'];
666
667  // makeCssRgb() can be called thousands of times. Using |rgbBuf| avoids
668  // creating many intermediate strings.
669  Util.makeCssRgb = function Util_makeCssRgb(r, g, b) {
670    rgbBuf[1] = r;
671    rgbBuf[3] = g;
672    rgbBuf[5] = b;
673    return rgbBuf.join('');
674  };
675
676  // Concatenates two transformation matrices together and returns the result.
677  Util.transform = function Util_transform(m1, m2) {
678    return [
679      m1[0] * m2[0] + m1[2] * m2[1],
680      m1[1] * m2[0] + m1[3] * m2[1],
681      m1[0] * m2[2] + m1[2] * m2[3],
682      m1[1] * m2[2] + m1[3] * m2[3],
683      m1[0] * m2[4] + m1[2] * m2[5] + m1[4],
684      m1[1] * m2[4] + m1[3] * m2[5] + m1[5]
685    ];
686  };
687
688  // For 2d affine transforms
689  Util.applyTransform = function Util_applyTransform(p, m) {
690    var xt = p[0] * m[0] + p[1] * m[2] + m[4];
691    var yt = p[0] * m[1] + p[1] * m[3] + m[5];
692    return [xt, yt];
693  };
694
695  Util.applyInverseTransform = function Util_applyInverseTransform(p, m) {
696    var d = m[0] * m[3] - m[1] * m[2];
697    var xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
698    var yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
699    return [xt, yt];
700  };
701
702  // Applies the transform to the rectangle and finds the minimum axially
703  // aligned bounding box.
704  Util.getAxialAlignedBoundingBox =
705    function Util_getAxialAlignedBoundingBox(r, m) {
706
707    var p1 = Util.applyTransform(r, m);
708    var p2 = Util.applyTransform(r.slice(2, 4), m);
709    var p3 = Util.applyTransform([r[0], r[3]], m);
710    var p4 = Util.applyTransform([r[2], r[1]], m);
711    return [
712      Math.min(p1[0], p2[0], p3[0], p4[0]),
713      Math.min(p1[1], p2[1], p3[1], p4[1]),
714      Math.max(p1[0], p2[0], p3[0], p4[0]),
715      Math.max(p1[1], p2[1], p3[1], p4[1])
716    ];
717  };
718
719  Util.inverseTransform = function Util_inverseTransform(m) {
720    var d = m[0] * m[3] - m[1] * m[2];
721    return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d,
722      (m[2] * m[5] - m[4] * m[3]) / d, (m[4] * m[1] - m[5] * m[0]) / d];
723  };
724
725  // Apply a generic 3d matrix M on a 3-vector v:
726  //   | a b c |   | X |
727  //   | d e f | x | Y |
728  //   | g h i |   | Z |
729  // M is assumed to be serialized as [a,b,c,d,e,f,g,h,i],
730  // with v as [X,Y,Z]
731  Util.apply3dTransform = function Util_apply3dTransform(m, v) {
732    return [
733      m[0] * v[0] + m[1] * v[1] + m[2] * v[2],
734      m[3] * v[0] + m[4] * v[1] + m[5] * v[2],
735      m[6] * v[0] + m[7] * v[1] + m[8] * v[2]
736    ];
737  };
738
739  // This calculation uses Singular Value Decomposition.
740  // The SVD can be represented with formula A = USV. We are interested in the
741  // matrix S here because it represents the scale values.
742  Util.singularValueDecompose2dScale =
743    function Util_singularValueDecompose2dScale(m) {
744
745    var transpose = [m[0], m[2], m[1], m[3]];
746
747    // Multiply matrix m with its transpose.
748    var a = m[0] * transpose[0] + m[1] * transpose[2];
749    var b = m[0] * transpose[1] + m[1] * transpose[3];
750    var c = m[2] * transpose[0] + m[3] * transpose[2];
751    var d = m[2] * transpose[1] + m[3] * transpose[3];
752
753    // Solve the second degree polynomial to get roots.
754    var first = (a + d) / 2;
755    var second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;
756    var sx = first + second || 1;
757    var sy = first - second || 1;
758
759    // Scale values are the square roots of the eigenvalues.
760    return [Math.sqrt(sx), Math.sqrt(sy)];
761  };
762
763  // Normalize rectangle rect=[x1, y1, x2, y2] so that (x1,y1) < (x2,y2)
764  // For coordinate systems whose origin lies in the bottom-left, this
765  // means normalization to (BL,TR) ordering. For systems with origin in the
766  // top-left, this means (TL,BR) ordering.
767  Util.normalizeRect = function Util_normalizeRect(rect) {
768    var r = rect.slice(0); // clone rect

769    if (rect[0] > rect[2]) {
770      r[0] = rect[2];
771      r[2] = rect[0];
772    }
773    if (rect[1] > rect[3]) {
774      r[1] = rect[3];
775      r[3] = rect[1];
776    }
777    return r;
778  };
779
780  // Returns a rectangle [x1, y1, x2, y2] corresponding to the
781  // intersection of rect1 and rect2. If no intersection, returns 'false'
782  // The rectangle coordinates of rect1, rect2 should be [x1, y1, x2, y2]
783  Util.intersect = function Util_intersect(rect1, rect2) {
784    function compare(a, b) {
785      return a - b;
786    }
787
788    // Order points along the axes
789    var orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare),
790        orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare),
791        result = [];
792
793    rect1 = Util.normalizeRect(rect1);
794    rect2 = Util.normalizeRect(rect2);
795
796    // X: first and second points belong to different rectangles?
797    if ((orderedX[0] === rect1[0] && orderedX[1] === rect2[0]) ||
798        (orderedX[0] === rect2[0] && orderedX[1] === rect1[0])) {
799      // Intersection must be between second and third points
800      result[0] = orderedX[1];
801      result[2] = orderedX[2];
802    } else {
803      return false;
804    }
805
806    // Y: first and second points belong to different rectangles?
807    if ((orderedY[0] === rect1[1] && orderedY[1] === rect2[1]) ||
808        (orderedY[0] === rect2[1] && orderedY[1] === rect1[1])) {
809      // Intersection must be between second and third points
810      result[1] = orderedY[1];
811      result[3] = orderedY[2];
812    } else {
813      return false;
814    }
815
816    return result;
817  };
818
819  Util.sign = function Util_sign(num) {
820    return num < 0 ? -1 : 1;
821  };
822
823  var ROMAN_NUMBER_MAP = [
824    '', 'C', 'CC', 'CCC', 'CD', 'D', 'DC', 'DCC', 'DCCC', 'CM',
825    '', 'X', 'XX', 'XXX', 'XL', 'L', 'LX', 'LXX', 'LXXX', 'XC',
826    '', 'I', 'II', 'III', 'IV', 'V', 'VI', 'VII', 'VIII', 'IX'
827  ];
828  /**
829   * Converts positive integers to (upper case) Roman numerals.
830   * @param {integer} number - The number that should be converted.
831   * @param {boolean} lowerCase - Indicates if the result should be converted
832   *   to lower case letters. The default is false.
833   * @return {string} The resulting Roman number.
834   */
835  Util.toRoman = function Util_toRoman(number, lowerCase) {
836    assert(isInt(number) && number > 0,
837           'The number should be a positive integer.');
838    var pos, romanBuf = [];
839    // Thousands
840    while (number >= 1000) {
841      number -= 1000;
842      romanBuf.push('M');
843    }
844    // Hundreds
845    pos = (number / 100) | 0;
846    number %= 100;
847    romanBuf.push(ROMAN_NUMBER_MAP[pos]);
848    // Tens
849    pos = (number / 10) | 0;
850    number %= 10;
851    romanBuf.push(ROMAN_NUMBER_MAP[10 + pos]);
852    // Ones
853    romanBuf.push(ROMAN_NUMBER_MAP[20 + number]);
854
855    var romanStr = romanBuf.join('');
856    return (lowerCase ? romanStr.toLowerCase() : romanStr);
857  };
858
859  Util.appendToArray = function Util_appendToArray(arr1, arr2) {
860    Array.prototype.push.apply(arr1, arr2);
861  };
862
863  Util.prependToArray = function Util_prependToArray(arr1, arr2) {
864    Array.prototype.unshift.apply(arr1, arr2);
865  };
866
867  Util.extendObj = function extendObj(obj1, obj2) {
868    for (var key in obj2) {
869      obj1[key] = obj2[key];
870    }
871  };
872
873  Util.getInheritableProperty = function Util_getInheritableProperty(dict,
874                                                                     name) {
875    while (dict && !dict.has(name)) {
876      dict = dict.get('Parent');
877    }
878    if (!dict) {
879      return null;
880    }
881    return dict.get(name);
882  };
883
884  Util.inherit = function Util_inherit(sub, base, prototype) {
885    sub.prototype = Object.create(base.prototype);
886    sub.prototype.constructor = sub;
887    for (var prop in prototype) {
888      sub.prototype[prop] = prototype[prop];
889    }
890  };
891
892  Util.loadScript = function Util_loadScript(src, callback) {
893    var script = document.createElement('script');
894    var loaded = false;
895    script.setAttribute('src', src);
896    if (callback) {
897      script.onload = function() {
898        if (!loaded) {
899          callback();
900        }
901        loaded = true;
902      };
903    }
904    document.getElementsByTagName('head')[0].appendChild(script);
905  };
906
907  return Util;
908})();
909
910/**
911 * PDF page viewport created based on scale, rotation and offset.
912 * @class
913 * @alias PageViewport
914 */
915var PageViewport = (function PageViewportClosure() {
916  /**
917   * @constructor
918   * @private
919   * @param viewBox {Array} xMin, yMin, xMax and yMax coordinates.
920   * @param scale {number} scale of the viewport.
921   * @param rotation {number} rotations of the viewport in degrees.
922   * @param offsetX {number} offset X
923   * @param offsetY {number} offset Y
924   * @param dontFlip {boolean} if true, axis Y will not be flipped.
925   */
926  function PageViewport(viewBox, scale, rotation, offsetX, offsetY, dontFlip) {
927    this.viewBox = viewBox;
928    this.scale = scale;
929    this.rotation = rotation;
930    this.offsetX = offsetX;
931    this.offsetY = offsetY;
932
933    // creating transform to convert pdf coordinate system to the normal
934    // canvas like coordinates taking in account scale and rotation
935    var centerX = (viewBox[2] + viewBox[0]) / 2;
936    var centerY = (viewBox[3] + viewBox[1]) / 2;
937    var rotateA, rotateB, rotateC, rotateD;
938    rotation = rotation % 360;
939    rotation = rotation < 0 ? rotation + 360 : rotation;
940    switch (rotation) {
941      case 180:
942        rotateA = -1; rotateB = 0; rotateC = 0; rotateD = 1;
943        break;
944      case 90:
945        rotateA = 0; rotateB = 1; rotateC = 1; rotateD = 0;
946        break;
947      case 270:
948        rotateA = 0; rotateB = -1; rotateC = -1; rotateD = 0;
949        break;
950      //case 0:
951      default:
952        rotateA = 1; rotateB = 0; rotateC = 0; rotateD = -1;
953        break;
954    }
955
956    if (dontFlip) {
957      rotateC = -rotateC; rotateD = -rotateD;
958    }
959
960    var offsetCanvasX, offsetCanvasY;
961    var width, height;
962    if (rotateA === 0) {
963      offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;
964      offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;
965      width = Math.abs(viewBox[3] - viewBox[1]) * scale;
966      height = Math.abs(viewBox[2] - viewBox[0]) * scale;
967    } else {
968      offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;
969      offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;
970      width = Math.abs(viewBox[2] - viewBox[0]) * scale;
971      height = Math.abs(viewBox[3] - viewBox[1]) * scale;
972    }
973    // creating transform for the following operations:
974    // translate(-centerX, -centerY), rotate and flip vertically,
975    // scale, and translate(offsetCanvasX, offsetCanvasY)
976    this.transform = [
977      rotateA * scale,
978      rotateB * scale,
979      rotateC * scale,
980      rotateD * scale,
981      offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY,
982      offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY
983    ];
984
985    this.width = width;
986    this.height = height;
987    this.fontScale = scale;
988  }
989  PageViewport.prototype = /** @lends PageViewport.prototype */ {
990    /**
991     * Clones viewport with additional properties.
992     * @param args {Object} (optional) If specified, may contain the 'scale' or
993     * 'rotation' properties to override the corresponding properties in
994     * the cloned viewport.
995     * @returns {PageViewport} Cloned viewport.
996     */
997    clone: function PageViewPort_clone(args) {
998      args = args || {};
999      var scale = 'scale' in args ? args.scale : this.scale;
1000      var rotation = 'rotation' in args ? args.rotation : this.rotation;
1001      return new PageViewport(this.viewBox.slice(), scale, rotation,
1002                              this.offsetX, this.offsetY, args.dontFlip);
1003    },
1004    /**
1005     * Converts PDF point to the viewport coordinates. For examples, useful for

1006     * converting PDF location into canvas pixel coordinates.
1007     * @param x {number} X coordinate.
1008     * @param y {number} Y coordinate.
1009     * @returns {Object} Object that contains 'x' and 'y' properties of the
1010     * point in the viewport coordinate space.
1011     * @see {@link convertToPdfPoint}
1012     * @see {@link convertToViewportRectangle}
1013     */
1014    convertToViewportPoint: function PageViewport_convertToViewportPoint(x, y) {
1015      return Util.applyTransform([x, y], this.transform);
1016    },
1017    /**
1018     * Converts PDF rectangle to the viewport coordinates.
1019     * @param rect {Array} xMin, yMin, xMax and yMax coordinates.
1020     * @returns {Array} Contains corresponding coordinates of the rectangle
1021     * in the viewport coordinate space.
1022     * @see {@link convertToViewportPoint}
1023     */
1024    convertToViewportRectangle:
1025      function PageViewport_convertToViewportRectangle(rect) {
1026      var tl = Util.applyTransform([rect[0], rect[1]], this.transform);
1027      var br = Util.applyTransform([rect[2], rect[3]], this.transform);
1028      return [tl[0], tl[1], br[0], br[1]];
1029    },
1030    /**
1031     * Converts viewport coordinates to the PDF location. For examples, useful
1032     * for converting canvas pixel location into PDF one.
1033     * @param x {number} X coordinate.
1034     * @param y {number} Y coordinate.
1035     * @returns {Object} Object that contains 'x' and 'y' properties of the
1036     * point in the PDF coordinate space.
1037     * @see {@link convertToViewportPoint}
1038     */
1039    convertToPdfPoint: function PageViewport_convertToPdfPoint(x, y) {
1040      return Util.applyInverseTransform([x, y], this.transform);
1041    }
1042  };
1043  return PageViewport;
1044})();
1045
1046var PDFStringTranslateTable = [
1047  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1048  0x2D8, 0x2C7, 0x2C6, 0x2D9, 0x2DD, 0x2DB, 0x2DA, 0x2DC, 0, 0, 0, 0, 0, 0, 0,
1049  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1050  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1051  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1052  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014,
1053  0x2013, 0x192, 0x2044, 0x2039, 0x203A, 0x2212, 0x2030, 0x201E, 0x201C,
1054  0x201D, 0x2018, 0x2019, 0x201A, 0x2122, 0xFB01, 0xFB02, 0x141, 0x152, 0x160,
1055  0x178, 0x17D, 0x131, 0x142, 0x153, 0x161, 0x17E, 0, 0x20AC
1056];
1057
1058function stringToPDFString(str) {
1059  var i, n = str.length, strBuf = [];
1060  if (str[0] === '\xFE' && str[1] === '\xFF') {
1061    // UTF16BE BOM
1062    for (i = 2; i < n; i += 2) {
1063      strBuf.push(String.fromCharCode(
1064        (str.charCodeAt(i) << 8) | str.charCodeAt(i + 1)));
1065    }
1066  } else {
1067    for (i = 0; i < n; ++i) {
1068      var code = PDFStringTranslateTable[str.charCodeAt(i)];
1069      strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
1070    }
1071  }
1072  return strBuf.join('');
1073}
1074
1075function stringToUTF8String(str) {
1076  return decodeURIComponent(escape(str));
1077}
1078
1079function utf8StringToString(str) {
1080  return unescape(encodeURIComponent(str));
1081}
1082
1083function isEmptyObj(obj) {
1084  for (var key in obj) {
1085    return false;
1086  }
1087  return true;
1088}
1089
1090function isBool(v) {
1091  return typeof v === 'boolean';
1092}
1093
1094function isInt(v) {
1095  return typeof v === 'number' && ((v | 0) === v);
1096}
1097
1098function isNum(v) {
1099  return typeof v === 'number';
1100}
1101
1102function isString(v) {
1103  return typeof v === 'string';
1104}
1105
1106function isArray(v) {
1107  return v instanceof Array;
1108}
1109
1110function isArrayBuffer(v) {
1111  return typeof v === 'object' && v !== null && v.byteLength !== undefined;
1112}
1113
1114/**
1115 * Promise Capability object.
1116 *
1117 * @typedef {Object} PromiseCapability
1118 * @property {Promise} promise - A promise object.
1119 * @property {function} resolve - Fullfills the promise.
1120 * @property {function} reject - Rejects the promise.
1121 */
1122
1123/**
1124 * Creates a promise capability object.
1125 * @alias createPromiseCapability
1126 *
1127 * @return {PromiseCapability} A capability object contains:
1128 * - a Promise, resolve and reject methods.
1129 */
1130function createPromiseCapability() {
1131  var capability = {};
1132  capability.promise = new Promise(function (resolve, reject) {
1133    capability.resolve = resolve;
1134    capability.reject = reject;
1135  });
1136  return capability;
1137}
1138
1139/**
1140 * Polyfill for Promises:
1141 * The following promise implementation tries to generally implement the
1142 * Promise/A+ spec. Some notable differences from other promise libaries are:
1143 * - There currently isn't a seperate deferred and promise object.
1144 * - Unhandled rejections eventually show an error if they aren't handled.
1145 *
1146 * Based off of the work in:
1147 * https://bugzilla.mozilla.org/show_bug.cgi?id=810490
1148 */
1149(function PromiseClosure() {
1150  if (globalScope.Promise) {
1151    // Promises existing in the DOM/Worker, checking presence of all/resolve
1152    if (typeof globalScope.Promise.all !== 'function') {
1153      globalScope.Promise.all = function (iterable) {
1154        var count = 0, results = [], resolve, reject;
1155        var promise = new globalScope.Promise(function (resolve_, reject_) {
1156          resolve = resolve_;
1157          reject = reject_;
1158        });
1159        iterable.forEach(function (p, i) {
1160          count++;
1161          p.then(function (result) {
1162            results[i] = result;
1163            count--;
1164            if (count === 0) {
1165              resolve(results);
1166            }
1167          }, reject);
1168        });
1169        if (count === 0) {
1170          resolve(results);
1171        }
1172        return promise;
1173      };
1174    }
1175    if (typeof globalScope.Promise.resolve !== 'function') {
1176      globalScope.Promise.resolve = function (value) {
1177        return new globalScope.Promise(function (resolve) { resolve(value); });
1178      };
1179    }
1180    if (typeof globalScope.Promise.reject !== 'function') {
1181      globalScope.Promise.reject = function (reason) {
1182        return new globalScope.Promise(function (resolve, reject) {
1183          reject(reason);
1184        });
1185      };
1186    }
1187    if (typeof globalScope.Promise.prototype.catch !== 'function') {
1188      globalScope.Promise.prototype.catch = function (onReject) {
1189        return globalScope.Promise.prototype.then(undefined, onReject);
1190      };
1191    }
1192    return;
1193  }
1194  var STATUS_PENDING = 0;
1195  var STATUS_RESOLVED = 1;
1196  var STATUS_REJECTED = 2;
1197
1198  // In an attempt to avoid silent exceptions, unhandled rejections are
1199  // tracked and if they aren't handled in a certain amount of time an
1200  // error is logged.
1201  var REJECTION_TIMEOUT = 500;
1202
1203  var HandlerManager = {
1204    handlers: [],
1205    running: false,
1206    unhandledRejections: [],
1207    pendingRejectionCheck: false,
1208
1209    scheduleHandlers: function scheduleHandlers(promise) {
1210      if (promise._status === STATUS_PENDING) {
1211        return;
1212      }
1213
1214      this.handlers = this.handlers.concat(promise._handlers);
1215      promise._handlers = [];
1216
1217      if (this.running) {
1218        return;
1219      }
1220      this.running = true;
1221
1222      setTimeout(this.runHandlers.bind(this), 0);
1223    },
1224
1225    runHandlers: function runHandlers() {
1226      var RUN_TIMEOUT = 1; // ms
1227      var timeoutAt = Date.now() + RUN_TIMEOUT;
1228      while (this.handlers.length > 0) {
1229        var handler = this.handlers.shift();
1230
1231        var nextStatus = handler.thisPromise._status;
1232        var nextValue = handler.thisPromise._value;
1233
1234        try {
1235          if (nextStatus === STATUS_RESOLVED) {
1236            if (typeof handler.onResolve === 'function') {
1237              nextValue = handler.onResolve(nextValue);
1238            }
1239          } else if (typeof handler.onReject === 'function') {
1240              nextValue = handler.onReject(nextValue);
1241              nextStatus = STATUS_RESOLVED;
1242
1243              if (handler.thisPromise._unhandledRejection) {
1244                this.removeUnhandeledRejection(handler.thisPromise);
1245              }
1246          }
1247        } catch (ex) {
1248          nextStatus = STATUS_REJECTED;
1249          nextValue = ex;
1250        }
1251
1252        handler.nextPromise._updateStatus(nextStatus, nextValue);
1253        if (Date.now() >= timeoutAt) {
1254          break;
1255        }
1256      }
1257
1258      if (this.handlers.length > 0) {
1259        setTimeout(this.runHandlers.bind(this), 0);
1260        return;
1261      }
1262
1263      this.running = false;
1264    },
1265
1266    addUnhandledRejection: function addUnhandledRejection(promise) {
1267      this.unhandledRejections.push({
1268        promise: promise,
1269        time: Date.now()
1270      });
1271      this.scheduleRejectionCheck();
1272    },
1273
1274    removeUnhandeledRejection: function removeUnhandeledRejection(promise) {
1275      promise._unhandledRejection = false;
1276      for (var i = 0; i < this.unhandledRejections.length; i++) {
1277        if (this.unhandledRejections[i].promise === promise) {
1278          this.unhandledRejections.splice(i);
1279          i--;
1280        }
1281      }
1282    },
1283
1284    scheduleRejectionCheck: function scheduleRejectionCheck() {
1285      if (this.pendingRejectionCheck) {
1286        return;
1287      }
1288      this.pendingRejectionCheck = true;
1289      setTimeout(function rejectionCheck() {
1290        this.pendingRejectionCheck = false;
1291        var now = Date.now();
1292        for (var i = 0; i < this.unhandledRejections.length; i++) {
1293          if (now - this.unhandledRejections[i].time > REJECTION_TIMEOUT) {
1294            var unhandled = this.unhandledRejections[i].promise._value;
1295            var msg = 'Unhandled rejection: ' + unhandled;
1296            if (unhandled.stack) {
1297              msg += '\n' + unhandled.stack;
1298            }
1299            warn(msg);
1300            this.unhandledRejections.splice(i);
1301            i--;
1302          }
1303        }
1304        if (this.unhandledRejections.length) {
1305          this.scheduleRejectionCheck();
1306        }
1307      }.bind(this), REJECTION_TIMEOUT);
1308    }
1309  };
1310
1311  function Promise(resolver) {
1312    this._status = STATUS_PENDING;
1313    this._handlers = [];
1314    try {
1315      resolver.call(this, this._resolve.bind(this), this._reject.bind(this));
1316    } catch (e) {
1317      this._reject(e);
1318    }
1319  }
1320  /**
1321   * Builds a promise that is resolved when all the passed in promises are
1322   * resolved.
1323   * @param {array} array of data and/or promises to wait for.
1324   * @return {Promise} New dependant promise.
1325   */
1326  Promise.all = function Promise_all(promises) {
1327    var resolveAll, rejectAll;
1328    var deferred = new Promise(function (resolve, reject) {
1329      resolveAll = resolve;
1330      rejectAll = reject;
1331    });
1332    var unresolved = promises.length;
1333    var results = [];
1334    if (unresolved === 0) {
1335      resolveAll(results);
1336      return deferred;
1337    }
1338    function reject(reason) {
1339      if (deferred._status === STATUS_REJECTED) {
1340        return;
1341      }
1342      results = [];
1343      rejectAll(reason);
1344    }
1345    for (var i = 0, ii = promises.length; i < ii; ++i) {
1346      var promise = promises[i];
1347      var resolve = (function(i) {
1348        return function(value) {
1349          if (deferred._status === STATUS_REJECTED) {
1350            return;
1351          }
1352          results[i] = value;
1353          unresolved--;
1354          if (unresolved === 0) {
1355            resolveAll(results);
1356          }
1357        };
1358      })(i);
1359      if (Promise.isPromise(promise)) {
1360        promise.then(resolve, reject);
1361      } else {
1362        resolve(promise);
1363      }
1364    }
1365    return deferred;
1366  };
1367
1368  /**
1369   * Checks if the value is likely a promise (has a 'then' function).
1370   * @return {boolean} true if value is thenable
1371   */
1372  Promise.isPromise = function Promise_isPromise(value) {
1373    return value && typeof value.then === 'function';
1374  };
1375
1376  /**
1377   * Creates resolved promise
1378   * @param value resolve value
1379   * @returns {Promise}
1380   */
1381  Promise.resolve = function Promise_resolve(value) {
1382    return new Promise(function (resolve) { resolve(value); });
1383  };
1384
1385  /**
1386   * Creates rejected promise
1387   * @param reason rejection value
1388   * @returns {Promise}
1389   */
1390  Promise.reject = function Promise_reject(reason) {
1391    return new Promise(function (resolve, reject) { reject(reason); });
1392  };
1393
1394  Promise.prototype = {
1395    _status: null,
1396    _value: null,
1397    _handlers: null,
1398    _unhandledRejection: null,
1399
1400    _updateStatus: function Promise__updateStatus(status, value) {
1401      if (this._status === STATUS_RESOLVED ||
1402          this._status === STATUS_REJECTED) {
1403        return;
1404      }
1405
1406      if (status === STATUS_RESOLVED &&
1407          Promise.isPromise(value)) {
1408        value.then(this._updateStatus.bind(this, STATUS_RESOLVED),
1409                   this._updateStatus.bind(this, STATUS_REJECTED));
1410        return;
1411      }
1412
1413      this._status = status;
1414      this._value = value;
1415
1416      if (status === STATUS_REJECTED && this._handlers.length === 0) {
1417        this._unhandledRejection = true;
1418        HandlerManager.addUnhandledRejection(this);
1419      }
1420
1421      HandlerManager.scheduleHandlers(this);
1422    },
1423
1424    _resolve: function Promise_resolve(value) {
1425      this._updateStatus(STATUS_RESOLVED, value);
1426    },
1427
1428    _reject: function Promise_reject(reason) {
1429      this._updateStatus(STATUS_REJECTED, reason);
1430    },
1431
1432    then: function Promise_then(onResolve, onReject) {
1433      var nextPromise = new Promise(function (resolve, reject) {
1434        this.resolve = resolve;
1435        this.reject = reject;
1436      });
1437      this._handlers.push({
1438        thisPromise: this,
1439        onResolve: onResolve,
1440        onReject: onReject,
1441        nextPromise: nextPromise
1442      });
1443      HandlerManager.scheduleHandlers(this);
1444      return nextPromise;
1445    },
1446

1447    catch: function Promise_catch(onReject) {
1448      return this.then(undefined, onReject);
1449    }
1450  };
1451
1452  globalScope.Promise = Promise;
1453})();
1454
1455var StatTimer = (function StatTimerClosure() {
1456  function rpad(str, pad, length) {
1457    while (str.length < length) {
1458      str += pad;
1459    }
1460    return str;
1461  }
1462  function StatTimer() {
1463    this.started = Object.create(null);
1464    this.times = [];
1465    this.enabled = true;
1466  }
1467  StatTimer.prototype = {
1468    time: function StatTimer_time(name) {
1469      if (!this.enabled) {
1470        return;
1471      }
1472      if (name in this.started) {
1473        warn('Timer is already running for ' + name);
1474      }
1475      this.started[name] = Date.now();
1476    },
1477    timeEnd: function StatTimer_timeEnd(name) {
1478      if (!this.enabled) {
1479        return;
1480      }
1481      if (!(name in this.started)) {
1482        warn('Timer has not been started for ' + name);
1483      }
1484      this.times.push({
1485        'name': name,
1486        'start': this.started[name],
1487        'end': Date.now()
1488      });
1489      // Remove timer from started so it can be called again.
1490      delete this.started[name];
1491    },
1492    toString: function StatTimer_toString() {
1493      var i, ii;
1494      var times = this.times;
1495      var out = '';
1496      // Find the longest name for padding purposes.
1497      var longest = 0;
1498      for (i = 0, ii = times.length; i < ii; ++i) {
1499        var name = times[i]['name'];
1500        if (name.length > longest) {
1501          longest = name.length;
1502        }
1503      }
1504      for (i = 0, ii = times.length; i < ii; ++i) {
1505        var span = times[i];
1506        var duration = span.end - span.start;
1507        out += rpad(span['name'], ' ', longest) + ' ' + duration + 'ms\n';
1508      }
1509      return out;
1510    }
1511  };
1512  return StatTimer;
1513})();
1514
1515var createBlob = function createBlob(data, contentType) {
1516  if (typeof Blob !== 'undefined') {
1517    return new Blob([data], { type: contentType });
1518  }
1519  // Blob builder is deprecated in FF14 and removed in FF18.
1520  var bb = new MozBlobBuilder();
1521  bb.append(data);
1522  return bb.getBlob(contentType);
1523};
1524
1525var createObjectURL = (function createObjectURLClosure() {
1526  // Blob/createObjectURL is not available, falling back to data schema.
1527  var digits =
1528    'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
1529
1530  return function createObjectURL(data, contentType, forceDataSchema) {
1531    if (!forceDataSchema &&
1532        typeof URL !== 'undefined' && URL.createObjectURL) {
1533      var blob = createBlob(data, contentType);
1534      return URL.createObjectURL(blob);
1535    }
1536
1537    var buffer = 'data:' + contentType + ';base64,';
1538    for (var i = 0, ii = data.length; i < ii; i += 3) {
1539      var b1 = data[i] & 0xFF;
1540      var b2 = data[i + 1] & 0xFF;
1541      var b3 = data[i + 2] & 0xFF;
1542      var d1 = b1 >> 2, d2 = ((b1 & 3) << 4) | (b2 >> 4);
1543      var d3 = i + 1 < ii ? ((b2 & 0xF) << 2) | (b3 >> 6) : 64;
1544      var d4 = i + 2 < ii ? (b3 & 0x3F) : 64;
1545      buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];
1546    }
1547    return buffer;
1548  };
1549})();
1550
1551function MessageHandler(sourceName, targetName, comObj) {
1552  this.sourceName = sourceName;
1553  this.targetName = targetName;
1554  this.comObj = comObj;
1555  this.callbackIndex = 1;
1556  this.postMessageTransfers = true;
1557  var callbacksCapabilities = this.callbacksCapabilities = Object.create(null);
1558  var ah = this.actionHandler = Object.create(null);
1559
1560  this._onComObjOnMessage = function messageHandlerComObjOnMessage(event) {
1561    var data = event.data;
1562    if (data.targetName !== this.sourceName) {
1563      return;
1564    }
1565    if (data.isReply) {
1566      var callbackId = data.callbackId;
1567      if (data.callbackId in callbacksCapabilities) {
1568        var callback = callbacksCapabilities[callbackId];
1569        delete callbacksCapabilities[callbackId];
1570        if ('error' in data) {
1571          callback.reject(data.error);
1572        } else {
1573          callback.resolve(data.data);
1574        }
1575      } else {
1576        error('Cannot resolve callback ' + callbackId);
1577      }
1578    } else if (data.action in ah) {
1579      var action = ah[data.action];
1580      if (data.callbackId) {
1581        var sourceName = this.sourceName;
1582        var targetName = data.sourceName;
1583        Promise.resolve().then(function () {
1584          return action[0].call(action[1], data.data);
1585        }).then(function (result) {
1586          comObj.postMessage({
1587            sourceName: sourceName,
1588            targetName: targetName,
1589            isReply: true,
1590            callbackId: data.callbackId,
1591            data: result
1592          });
1593        }, function (reason) {
1594          if (reason instanceof Error) {
1595            // Serialize error to avoid "DataCloneError"
1596            reason = reason + '';
1597          }
1598          comObj.postMessage({
1599            sourceName: sourceName,
1600            targetName: targetName,
1601            isReply: true,
1602            callbackId: data.callbackId,
1603            error: reason
1604          });
1605        });
1606      } else {
1607        action[0].call(action[1], data.data);
1608      }
1609    } else {
1610      error('Unknown action from worker: ' + data.action);
1611    }
1612  }.bind(this);
1613  comObj.addEventListener('message', this._onComObjOnMessage);
1614}
1615
1616MessageHandler.prototype = {
1617  on: function messageHandlerOn(actionName, handler, scope) {
1618    var ah = this.actionHandler;
1619    if (ah[actionName]) {
1620      error('There is already an actionName called "' + actionName + '"');
1621    }
1622    ah[actionName] = [handler, scope];
1623  },
1624  /**
1625   * Sends a message to the comObj to invoke the action with the supplied data.
1626   * @param {String} actionName Action to call.
1627   * @param {JSON} data JSON data to send.
1628   * @param {Array} [transfers] Optional list of transfers/ArrayBuffers
1629   */
1630  send: function messageHandlerSend(actionName, data, transfers) {
1631    var message = {
1632      sourceName: this.sourceName,
1633      targetName: this.targetName,
1634      action: actionName,
1635      data: data
1636    };
1637    this.postMessage(message, transfers);
1638  },
1639  /**
1640   * Sends a message to the comObj to invoke the action with the supplied data.
1641   * Expects that other side will callback with the response.
1642   * @param {String} actionName Action to call.
1643   * @param {JSON} data JSON data to send.
1644   * @param {Array} [transfers] Optional list of transfers/ArrayBuffers.
1645   * @returns {Promise} Promise to be resolved with response data.
1646   */

1737  function invalid() {
1738    clear.call(this);
1739    this._isInvalid = true;
1740  }
1741
1742  function IDNAToASCII(h) {
1743    if ('' == h) {
1744      invalid.call(this)
1745    }
1746    // XXX
1747    return h.toLowerCase()
1748  }
1749
1750  function percentEscape(c) {
1751    var unicode = c.charCodeAt(0);
1752    if (unicode > 0x20 &&
1753       unicode < 0x7F &&
1754       // " # < > ? `
1755       [0x22, 0x23, 0x3C, 0x3E, 0x3F, 0x60].indexOf(unicode) == -1
1756      ) {
1757      return c;
1758    }
1759    return encodeURIComponent(c);
1760  }
1761
1762  function percentEscapeQuery(c) {
1763    // XXX This actually needs to encode c using encoding and then
1764    // convert the bytes one-by-one.
1765
1766    var unicode = c.charCodeAt(0);
1767    if (unicode > 0x20 &&
1768       unicode < 0x7F &&
1769       // " # < > ` (do not escape '?')
1770       [0x22, 0x23, 0x3C, 0x3E, 0x60].indexOf(unicode) == -1
1771      ) {
1772      return c;
1773    }
1774    return encodeURIComponent(c);
1775  }
1776
1777  var EOF = undefined,
1778      ALPHA = /[a-zA-Z]/,
1779      ALPHANUMERIC = /[a-zA-Z0-9\+\-\.]/;
1780
1781  function parse(input, stateOverride, base) {
1782    function err(message) {
1783      errors.push(message)
1784    }
1785
1786    var state = stateOverride || 'scheme start',
1787        cursor = 0,
1788        buffer = '',
1789        seenAt = false,
1790        seenBracket = false,
1791        errors = [];
1792
1793    loop: while ((input[cursor - 1] != EOF || cursor == 0) && !this._isInvalid) {
1794      var c = input[cursor];
1795      switch (state) {
1796        case 'scheme start':
1797          if (c && ALPHA.test(c)) {
1798            buffer += c.toLowerCase(); // ASCII-safe
1799            state = 'scheme';
1800          } else if (!stateOverride) {
1801            buffer = '';
1802            state = 'no scheme';
1803            continue;
1804          } else {
1805            err('Invalid scheme.');
1806            break loop;
1807          }
1808          break;
1809
1810        case 'scheme':
1811          if (c && ALPHANUMERIC.test(c)) {
1812            buffer += c.toLowerCase(); // ASCII-safe
1813          } else if (':' == c) {
1814            this._scheme = buffer;
1815            buffer = '';
1816            if (stateOverride) {
1817              break loop;
1818            }
1819            if (isRelativeScheme(this._scheme)) {
1820              this._isRelative = true;
1821            }
1822            if ('file' == this._scheme) {
1823              state = 'relative';
1824            } else if (this._isRelative && base && base._scheme == this._scheme) {
1825              state = 'relative or authority';
1826            } else if (this._isRelative) {
1827              state = 'authority first slash';
1828            } else {
1829              state = 'scheme data';
1830            }
1831          } else if (!stateOverride) {
1832            buffer = '';
1833            cursor = 0;
1834            state = 'no scheme';
1835            continue;
1836          } else if (EOF == c) {
1837            break loop;
1838          } else {
1839            err('Code point not allowed in scheme: ' + c)
1840            break loop;
1841          }
1842          break;
1843
1844        case 'scheme data':
1845          if ('?' == c) {
1846            this._query = '?';
1847            state = 'query';
1848          } else if ('#' == c) {
1849            this._fragment = '#';
1850            state = 'fragment';
1851          } else {
1852            // XXX error handling
1853            if (EOF != c && '\t' != c && '\n' != c && '\r' != c) {
1854              this._schemeData += percentEscape(c);
1855            }
1856          }
1857          break;
1858
1859        case 'no scheme':
1860          if (!base || !(isRelativeScheme(base._scheme))) {
1861            err('Missing scheme.');
1862            invalid.call(this);
1863          } else {
1864            state = 'relative';
1865            continue;
1866          }
1867          break;
1868
1869        case 'relative or authority':
1870          if ('/' == c && '/' == input[cursor+1]) {
1871            state = 'authority ignore slashes';
1872          } else {
1873            err('Expected /, got: ' + c);
1874            state = 'relative';
1875            continue
1876          }
1877          break;
1878
1879        case 'relative':
1880          this._isRelative = true;
1881          if ('file' != this._scheme)
1882            this._scheme = base._scheme;
1883          if (EOF == c) {
1884            this._host = base._host;
1885            this._port = base._port;
1886            this._path = base._path.slice();
1887            this._query = base._query;
1888            this._username = base._username;
1889            this._password = base._password;
1890            break loop;
1891          } else if ('/' == c || '\\' == c) {
1892            if ('\\' == c)

1893              err('\\ is an invalid code point.');
1894            state = 'relative slash';
1895          } else if ('?' == c) {
1896            this._host = base._host;
1897            this._port = base._port;
1898            this._path = base._path.slice();
1899            this._query = '?';
1900            this._username = base._username;
1901            this._password = base._password;
1902            state = 'query';
1903          } else if ('#' == c) {
1904            this._host = base._host;
1905            this._port = base._port;
1906            this._path = base._path.slice();
1907            this._query = base._query;
1908            this._fragment = '#';
1909            this._username = base._username;
1910            this._password = base._password;
1911            state = 'fragment';
1912          } else {
1913            var nextC = input[cursor+1]
1914            var nextNextC = input[cursor+2]
1915            if (
1916              'file' != this._scheme || !ALPHA.test(c) ||
1917              (nextC != ':' && nextC != '|') ||
1918              (EOF != nextNextC && '/' != nextNextC && '\\' != nextNextC && '?' != nextNextC && '#' != nextNextC)) {
1919              this._host = base._host;
1920              this._port = base._port;
1921              this._username = base._username;
1922              this._password = base._password;
1923              this._path = base._path.slice();
1924              this._path.pop();
1925            }
1926            state = 'relative path';
1927            continue;
1928          }
1929          break;
1930
1931        case 'relative slash':
1932          if ('/' == c || '\\' == c) {
1933            if ('\\' == c) {
1934              err('\\ is an invalid code point.');
1935            }
1936            if ('file' == this._scheme) {
1937              state = 'file host';
1938            } else {
1939              state = 'authority ignore slashes';
1940            }
1941          } else {
1942            if ('file' != this._scheme) {
1943              this._host = base._host;
1944              this._port = base._port;
1945              this._username = base._username;
1946              this._password = base._password;
1947            }
1948            state = 'relative path';
1949            continue;
1950          }
1951          break;
1952
1953        case 'authority first slash':
1954          if ('/' == c) {
1955            state = 'authority second slash';
1956          } else {
1957            err("Expected '/', got: " + c);
1958            state = 'authority ignore slashes';
1959            continue;
1960          }
1961          break;
1962
1963        case 'authority second slash':
1964          state = 'authority ignore slashes';
1965          if ('/' != c) {
1966            err("Expected '/', got: " + c);
1967            continue;
1968          }
1969          break;
1970
1971        case 'authority ignore slashes':
1972          if ('/' != c && '\\' != c) {
1973            state = 'authority';
1974            continue;
1975          } else {
1976            err('Expected authority, got: ' + c);
1977          }
1978          break;
1979
1980        case 'authority':
1981          if ('@' == c) {
1982            if (seenAt) {
1983              err('@ already seen.');
1984              buffer += '%40';
1985            }
1986            seenAt = true;
1987            for (var i = 0; i < buffer.length; i++) {
1988              var cp = buffer[i];
1989              if ('\t' == cp || '\n' == cp || '\r' == cp) {
1990                err('Invalid whitespace in authority.');
1991                continue;
1992              }
1993              // XXX check URL code points
1994              if (':' == cp && null === this._password) {
1995                this._password = '';
1996                continue;
1997              }
1998              var tempC = percentEscape(cp);
1999              (null !== this._password) ? this._password += tempC : this._username += tempC;
2000            }
2001            buffer = '';
2002          } else if (EOF == c || '/' == c || '\\' == c || '?' == c || '#' == c) {
2003            cursor -= buffer.length;
2004            buffer = '';
2005            state = 'host';
2006            continue;
2007          } else {
2008            buffer += c;
2009          }
2010          break;
2011
2012        case 'file host':
2013          if (EOF == c || '/' == c || '\\' == c || '?' == c || '#' == c) {
2014            if (buffer.length == 2 && ALPHA.test(buffer[0]) && (buffer[1] == ':' || buffer[1] == '|')) {
2015              state = 'relative path';
2016            } else if (buffer.length == 0) {
2017              state = 'relative path start';
2018            } else {

2019              this._host = IDNAToASCII.call(this, buffer);
2020              buffer = '';
2021              state = 'relative path start';
2022            }
2023            continue;
2024          } else if ('\t' == c || '\n' == c || '\r' == c) {
2025            err('Invalid whitespace in file host.');
2026          } else {
2027            buffer += c;
2028          }
2029          break;
2030
2031        case 'host':
2032        case 'hostname':
2033          if (':' == c && !seenBracket) {
2034            // XXX host parsing
2035            this._host = IDNAToASCII.call(this, buffer);
2036            buffer = '';
2037            state = 'port';
2038            if ('hostname' == stateOverride) {
2039              break loop;
2040            }
2041          } else if (EOF == c || '/' == c || '\\' == c || '?' == c || '#' == c) {
2042            this._host = IDNAToASCII.call(this, buffer);
2043            buffer = '';
2044            state = 'relative path start';
2045            if (stateOverride) {
2046              break loop;
2047            }
2048            continue;
2049          } else if ('\t' != c && '\n' != c && '\r' != c) {
2050            if ('[' == c) {
2051              seenBracket = true;
2052            } else if (']' == c) {
2053              seenBracket = false;
2054            }
2055            buffer += c;
2056          } else {
2057            err('Invalid code point in host/hostname: ' + c);
2058          }
2059          break;
2060
2061        case 'port':
2062          if (/[0-9]/.test(c)) {
2063            buffer += c;
2064          } else if (EOF == c || '/' == c || '\\' == c || '?' == c || '#' == c || stateOverride) {
2065            if ('' != buffer) {
2066              var temp = parseInt(buffer, 10);
2067              if (temp != relative[this._scheme]) {
2068                this._port = temp + '';
2069              }
2070              buffer = '';
2071            }
2072            if (stateOverride) {
2073              break loop;
2074            }
2075            state = 'relative path start';
2076            continue;
2077          } else if ('\t' == c || '\n' == c || '\r' == c) {
2078            err('Invalid code point in port: ' + c);
2079          } else {
2080            invalid.call(this);
2081          }
2082          break;
2083
2084        case 'relative path start':
2085          if ('\\' == c)
2086            err("'\\' not allowed in path.");
2087          state = 'relative path';
2088          if ('/' != c && '\\' != c) {
2089            continue;
2090          }
2091          break;
2092
2093        case 'relative path':
2094          if (EOF == c || '/' == c || '\\' == c || (!stateOverride && ('?' == c || '#' == c))) {
2095            if ('\\' == c) {
2096              err('\\ not allowed in relative path.');
2097            }
2098            var tmp;
2099            if (tmp = relativePathDotMapping[buffer.toLowerCase()]) {
2100              buffer = tmp;
2101            }
2102            if ('..' == buffer) {
2103              this._path.pop();
2104              if ('/' != c && '\\' != c) {
2105                this._path.push('');
2106              }
2107            } else if ('.' == buffer && '/' != c && '\\' != c) {
2108              this._path.push('');
2109            } else if ('.' != buffer) {
2110              if ('file' == this._scheme && this._path.length == 0 && buffer.length == 2 && ALPHA.test(buffer[0]) && buffer[1] == '|') {
2111                buffer = buffer[0] + ':';
2112              }
2113              this._path.push(buffer);
2114            }
2115            buffer = '';
2116            if ('?' == c) {
2117              this._query = '?';
2118              state = 'query';
2119            } else if ('#' == c) {
2120              this._fragment = '#';
2121              state = 'fragment';
2122            }
2123          } else if ('\t' != c && '\n' != c && '\r' != c) {
2124            buffer += percentEscape(c);
2125          }
2126          break;
2127
2128        case 'query':
2129          if (!stateOverride && '#' == c) {
2130            this._fragment = '#';
2131            state = 'fragment';
2132          } else if (EOF != c && '\t' != c && '\n' != c && '\r' != c) {
2133            this._query += percentEscapeQuery(c);
2134          }
2135          break;
2136
2137        case 'fragment':
2138          if (EOF != c && '\t' != c && '\n' != c && '\r' != c) {
2139            this._fragment += c;
2140          }
2141          break;
2142      }
2143
2144      cursor++;
2145    }
2146  }
2147
2148  function clear() {
2149    this._scheme = '';
2150    this._schemeData = '';
2151    this._username = '';
2152    this._password = null;
2153    this._host = '';
2154    this._port = '';
2155    this._path = [];
2156    this._query = '';
2157    this._fragment = '';
2158    this._isInvalid = false;
2159    this._isRelative = false;
2160  }
2161
2162  // Does not process domain names or IP addresses.
2163  // Does not handle encoding for the query parameter.
2164  function jURL(url, base /* , encoding */) {
2165    if (base !== undefined && !(base instanceof jURL))
2166      base = new jURL(String(base));
2167
2168    this._url = url;
2169    clear.call(this);
2170
2171    var input = url.replace(/^[ \t\r\n\f]+|[ \t\r\n\f]+$/g, '');
2172    // encoding = encoding || 'utf-8'
2173
2174    parse.call(this, input, null, base);
2175  }
2176
2177  jURL.prototype = {
2178    toString: function() {
2179      return this.href;
2180    },
2181    get href() {
2182      if (this._isInvalid)
2183        return this._url;
2184
2185      var authority = '';
2186      if ('' != this._username || null != this._password) {
2187        authority = this._username +
2188            (null != this._password ? ':' + this._password : '') + '@';
2189      }
2190
2191      return this.protocol +
2192          (this._isRelative ? '//' + authority + this.host : '') +
2193          this.pathname + this._query + this._fragment;
2194    },
2195    set href(href) {
2196      clear.call(this);
2197      parse.call(this, href);
2198    },
2199
2200    get protocol() {
2201      return this._scheme + ':';
2202    },
2203    set protocol(protocol) {
2204      if (this._isInvalid)
2205        return;
2206      parse.call(this, protocol + ':', 'scheme start');
2207    },
2208
2209    get host() {
2210      return this._isInvalid ? '' : this._port ?
2211          this._host + ':' + this._port : this._host;
2212    },
2213    set host(host) {
2214      if (this._isInvalid || !this._isRelative)
2215        return;
2216      parse.call(this, host, 'host');
2217    },
2218
2219    get hostname() {
2220      return this._host;
2221    },
2222    set hostname(hostname) {
2223      if (this._isInvalid || !this._isRelative)
2224        return;
2225      parse.call(this, hostname, 'hostname');
2226    },
2227
2228    get port() {
2229      return this._port;
2230    },
2231    set port(port) {
2232      if (this._isInvalid || !this._isRelative)
2233        return;
2234      parse.call(this, port, 'port');
2235    },
2236
2237    get pathname() {
2238      return this._isInvalid ? '' : this._isRelative ?
2239          '/' + this._path.join('/') : this._schemeData;
2240    },
2241    set pathname(pathname) {
2242      if (this._isInvalid || !this._isRelative)
2243        return;
2244      this._path = [];
2245      parse.call(this, pathname, 'relative path start');
2246    },
2247
2248    get search() {
2249      return this._isInvalid || !this._query || '?' == this._query ?
2250          '' : this._query;
2251    },
2252    set search(search) {
2253      if (this._isInvalid || !this._isRelative)
2254        return;
2255      this._query = '?';
2256      if ('?' == search[0])
2257        search = search.slice(1);
2258      parse.call(this, search, 'query');
2259    },
2260
2261    get hash() {
2262      return this._isInvalid || !this._fragment || '#' == this._fragment ?
2263          '' : this._fragment;
2264    },
2265    set hash(hash) {
2266      if (this._isInvalid)
2267        return;
2268      this._fragment = '#';
2269      if ('#' == hash[0])
2270        hash = hash.slice(1);
2271      parse.call(this, hash, 'fragment');
2272    },
2273
2274    get origin() {
2275      var host;
2276      if (this._isInvalid || !this._scheme) {
2277        return '';
2278      }
2279      // javascript: Gecko returns String(""), WebKit/Blink String("null")
2280      // Gecko throws error for "data://"
2281      // data: Gecko returns "", Blink returns "data://", WebKit returns "null"
2282      // Gecko returns String("") for file: mailto:
2283      // WebKit/Blink returns String("SCHEME://") for file: mailto:
2284      switch (this._scheme) {
2285        case 'data':
2286        case 'file':
2287        case 'javascript':
2288        case 'mailto':
2289          return 'null';
2290      }
2291      host = this.host;
2292      if (!host) {
2293        return '';
2294      }
2295      return this._scheme + '://' + host;
2296    }
2297  };
2298
2299  // Copy over the static methods
2300  var OriginalURL = scope.URL;
2301  if (OriginalURL) {
2302    jURL.createObjectURL = function(blob) {
2303      // IE extension allows a second optional options argument.
2304      // http://msdn.microsoft.com/en-us/library/ie/hh772302(v=vs.85).aspx
2305      return OriginalURL.createObjectURL.apply(OriginalURL, arguments);
2306    };
2307    jURL.revokeObjectURL = function(url) {
2308      OriginalURL.revokeObjectURL(url);
2309    };
2310  }
2311
2312  scope.URL = jURL;
2313  /* jshint ignore:end */
2314})(globalScope);
2315
2316exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
2317exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
2318exports.OPS = OPS;
2319exports.VERBOSITY_LEVELS = VERBOSITY_LEVELS;
2320exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES;
2321exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
2322exports.AnnotationFlag = AnnotationFlag;
2323exports.AnnotationType = AnnotationType;
2324exports.FontType = FontType;
2325exports.ImageKind = ImageKind;
2326exports.InvalidPDFException = InvalidPDFException;
2327exports.MessageHandler = MessageHandler;
2328exports.MissingDataException = MissingDataException;
2329exports.MissingPDFException = MissingPDFException;
2330exports.NotImplementedException = NotImplementedException;
2331exports.PageViewport = PageViewport;
2332exports.PasswordException = PasswordException;
2333exports.PasswordResponses = PasswordResponses;
2334exports.StatTimer = StatTimer;
2335exports.StreamType = StreamType;
2336exports.TextRenderingMode = TextRenderingMode;
2337exports.UnexpectedResponseException = UnexpectedResponseException;
2338exports.UnknownErrorException = UnknownErrorException;
2339exports.Util = Util;
2340exports.XRefParseException = XRefParseException;
2341exports.arrayByteLength = arrayByteLength;
2342exports.arraysToBytes = arraysToBytes;
2343exports.assert = assert;
2344exports.bytesToString = bytesToString;
2345exports.createBlob = createBlob;
2346exports.createPromiseCapability = createPromiseCapability;
2347exports.createObjectURL = createObjectURL;
2348exports.deprecated = deprecated;
2349exports.error = error;
2350exports.getLookupTableFactory = getLookupTableFactory;
2351exports.getVerbosityLevel = getVerbosityLevel;
2352exports.globalScope = globalScope;
2353exports.info = info;
2354exports.isArray = isArray;
2355exports.isArrayBuffer = isArrayBuffer;
2356exports.isBool = isBool;
2357exports.isEmptyObj = isEmptyObj;
2358exports.isInt = isInt;
2359exports.isNum = isNum;
2360exports.isString = isString;
2361exports.isSameOrigin = isSameOrigin;
2362exports.isValidUrl = isValidUrl;
2363exports.isLittleEndian = isLittleEndian;
2364exports.isEvalSupported = isEvalSupported;
2365exports.loadJpegStream = loadJpegStream;
2366exports.log2 = log2;
2367exports.readInt8 = readInt8;
2368exports.readUint16 = readUint16;
2369exports.readUint32 = readUint32;
2370exports.removeNullCharacters = removeNullCharacters;
2371exports.setVerbosityLevel = setVerbosityLevel;
2372exports.shadow = shadow;
2373exports.string32 = string32;
2374exports.stringToBytes = stringToBytes;
2375exports.stringToPDFString = stringToPDFString;
2376exports.stringToUTF8String = stringToUTF8String;
2377exports.utf8StringToString = utf8StringToString;
2378exports.warn = warn;
2379}));
2380
2381
2382(function (root, factory) {
2383  {
2384    factory((root.pdfjsDisplayDOMUtils = {}), root.pdfjsSharedUtil);
2385  }
2386}(this, function (exports, sharedUtil) {
2387
2388var removeNullCharacters = sharedUtil.removeNullCharacters;
2389var warn = sharedUtil.warn;
2390
2391/**
2392 * Optimised CSS custom property getter/setter.
2393 * @class
2394 */
2395var CustomStyle = (function CustomStyleClosure() {
2396
2397  // As noted on: http://www.zachstronaut.com/posts/2009/02/17/
2398  //              animate-css-transforms-firefox-webkit.html
2399  // in some versions of IE9 it is critical that ms appear in this list
2400  // before Moz
2401  var prefixes = ['ms', 'Moz', 'Webkit', 'O'];
2402  var _cache = Object.create(null);
2403
2404  function CustomStyle() {}
2405
2406  CustomStyle.getProp = function get(propName, element) {
2407    // check cache only when no element is given