https://szs.org.pl/wp-content/plugins/wp-file-download/app/site/assets/js/pdf-embed/pdf-old.js?ver=6.3.6

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// Checks if ch is one of the following characters: SPACE, TAB, CR or LF.
1115function isSpace(ch) {
1116  return (ch === 0x20 || ch === 0x09 || ch === 0x0D || ch === 0x0A);
1117}
1118
1119/**
1120 * Promise Capability object.
1121 *
1122 * @typedef {Object} PromiseCapability
1123 * @property {Promise} promise - A promise object.
1124 * @property {function} resolve - Fullfills the promise.
1125 * @property {function} reject - Rejects the promise.
1126 */
1127
1128/**
1129 * Creates a promise capability object.
1130 * @alias createPromiseCapability
1131 *
1132 * @return {PromiseCapability} A capability object contains:
1133 * - a Promise, resolve and reject methods.
1134 */
1135function createPromiseCapability() {
1136  var capability = {};
1137  capability.promise = new Promise(function (resolve, reject) {
1138    capability.resolve = resolve;
1139    capability.reject = reject;
1140  });
1141  return capability;
1142}
1143
1144/**
1145 * Polyfill for Promises:
1146 * The following promise implementation tries to generally implement the
1147 * Promise/A+ spec. Some notable differences from other promise libaries are:
1148 * - There currently isn't a seperate deferred and promise object.
1149 * - Unhandled rejections eventually show an error if they aren't handled.
1150 *
1151 * Based off of the work in:
1152 * https://bugzilla.mozilla.org/show_bug.cgi?id=810490
1153 */
1154(function PromiseClosure() {
1155  if (globalScope.Promise) {
1156    // Promises existing in the DOM/Worker, checking presence of all/resolve
1157    if (typeof globalScope.Promise.all !== 'function') {
1158      globalScope.Promise.all = function (iterable) {
1159        var count = 0, results = [], resolve, reject;
1160        var promise = new globalScope.Promise(function (resolve_, reject_) {
1161          resolve = resolve_;
1162          reject = reject_;
1163        });
1164        iterable.forEach(function (p, i) {
1165          count++;
1166          p.then(function (result) {
1167            results[i] = result;
1168            count--;
1169            if (count === 0) {
1170              resolve(results);
1171            }
1172          }, reject);
1173        });
1174        if (count === 0) {
1175          resolve(results);
1176        }
1177        return promise;
1178      };
1179    }
1180    if (typeof globalScope.Promise.resolve !== 'function') {
1181      globalScope.Promise.resolve = function (value) {
1182        return new globalScope.Promise(function (resolve) { resolve(value); });
1183      };
1184    }
1185    if (typeof globalScope.Promise.reject !== 'function') {
1186      globalScope.Promise.reject = function (reason) {
1187        return new globalScope.Promise(function (resolve, reject) {
1188          reject(reason);
1189        });
1190      };
1191    }
1192    if (typeof globalScope.Promise.prototype.catch !== 'function') {
1193      globalScope.Promise.prototype.catch = function (onReject) {
1194        return globalScope.Promise.prototype.then(undefined, onReject);
1195      };
1196    }
1197    return;
1198  }
1199  var STATUS_PENDING = 0;
1200  var STATUS_RESOLVED = 1;
1201  var STATUS_REJECTED = 2;
1202
1203  // In an attempt to avoid silent exceptions, unhandled rejections are
1204  // tracked and if they aren't handled in a certain amount of time an
1205  // error is logged.
1206  var REJECTION_TIMEOUT = 500;
1207
1208  var HandlerManager = {
1209    handlers: [],
1210    running: false,
1211    unhandledRejections: [],

1212    pendingRejectionCheck: false,
1213
1214    scheduleHandlers: function scheduleHandlers(promise) {
1215      if (promise._status === STATUS_PENDING) {
1216        return;
1217      }
1218
1219      this.handlers = this.handlers.concat(promise._handlers);
1220      promise._handlers = [];
1221
1222      if (this.running) {
1223        return;
1224      }
1225      this.running = true;
1226
1227      setTimeout(this.runHandlers.bind(this), 0);
1228    },
1229
1230    runHandlers: function runHandlers() {
1231      var RUN_TIMEOUT = 1; // ms
1232      var timeoutAt = Date.now() + RUN_TIMEOUT;
1233      while (this.handlers.length > 0) {
1234        var handler = this.handlers.shift();
1235
1236        var nextStatus = handler.thisPromise._status;
1237        var nextValue = handler.thisPromise._value;
1238
1239        try {
1240          if (nextStatus === STATUS_RESOLVED) {
1241            if (typeof handler.onResolve === 'function') {
1242              nextValue = handler.onResolve(nextValue);
1243            }
1244          } else if (typeof handler.onReject === 'function') {
1245              nextValue = handler.onReject(nextValue);
1246              nextStatus = STATUS_RESOLVED;
1247
1248              if (handler.thisPromise._unhandledRejection) {
1249                this.removeUnhandeledRejection(handler.thisPromise);
1250              }
1251          }
1252        } catch (ex) {
1253          nextStatus = STATUS_REJECTED;
1254          nextValue = ex;
1255        }
1256
1257        handler.nextPromise._updateStatus(nextStatus, nextValue);
1258        if (Date.now() >= timeoutAt) {
1259          break;
1260        }
1261      }
1262
1263      if (this.handlers.length > 0) {
1264        setTimeout(this.runHandlers.bind(this), 0);
1265        return;
1266      }
1267
1268      this.running = false;
1269    },
1270
1271    addUnhandledRejection: function addUnhandledRejection(promise) {
1272      this.unhandledRejections.push({
1273        promise: promise,
1274        time: Date.now()
1275      });
1276      this.scheduleRejectionCheck();
1277    },
1278
1279    removeUnhandeledRejection: function removeUnhandeledRejection(promise) {
1280      promise._unhandledRejection = false;
1281      for (var i = 0; i < this.unhandledRejections.length; i++) {
1282        if (this.unhandledRejections[i].promise === promise) {
1283          this.unhandledRejections.splice(i);
1284          i--;
1285        }
1286      }
1287    },
1288
1289    scheduleRejectionCheck: function scheduleRejectionCheck() {
1290      if (this.pendingRejectionCheck) {
1291        return;
1292      }
1293      this.pendingRejectionCheck = true;
1294      setTimeout(function rejectionCheck() {
1295        this.pendingRejectionCheck = false;
1296        var now = Date.now();
1297        for (var i = 0; i < this.unhandledRejections.length; i++) {
1298          if (now - this.unhandledRejections[i].time > REJECTION_TIMEOUT) {
1299            var unhandled = this.unhandledRejections[i].promise._value;
1300            var msg = 'Unhandled rejection: ' + unhandled;
1301            if (unhandled.stack) {
1302              msg += '\n' + unhandled.stack;
1303            }
1304            warn(msg);
1305            this.unhandledRejections.splice(i);
1306            i--;
1307          }
1308        }
1309        if (this.unhandledRejections.length) {
1310          this.scheduleRejectionCheck();
1311        }
1312      }.bind(this), REJECTION_TIMEOUT);
1313    }
1314  };
1315
1316  function Promise(resolver) {
1317    this._status = STATUS_PENDING;
1318    this._handlers = [];
1319    try {
1320      resolver.call(this, this._resolve.bind(this), this._reject.bind(this));
1321    } catch (e) {
1322      this._reject(e);
1323    }
1324  }
1325  /**
1326   * Builds a promise that is resolved when all the passed in promises are
1327   * resolved.
1328   * @param {array} promises array of data and/or promises to wait for.
1329   * @return {Promise} New dependant promise.
1330   */
1331  Promise.all = function Promise_all(promises) {
1332    var resolveAll, rejectAll;
1333    var deferred = new Promise(function (resolve, reject) {
1334      resolveAll = resolve;
1335      rejectAll = reject;
1336    });
1337    var unresolved = promises.length;
1338    var results = [];
1339    if (unresolved === 0) {
1340      resolveAll(results);
1341      return deferred;
1342    }
1343    function reject(reason) {
1344      if (deferred._status === STATUS_REJECTED) {
1345        return;
1346      }
1347      results = [];
1348      rejectAll(reason);
1349    }
1350    for (var i = 0, ii = promises.length; i < ii; ++i) {
1351      var promise = promises[i];
1352      var resolve = (function(i) {
1353        return function(value) {
1354          if (deferred._status === STATUS_REJECTED) {
1355            return;
1356          }
1357          results[i] = value;
1358          unresolved--;
1359          if (unresolved === 0) {
1360            resolveAll(results);
1361          }
1362        };
1363      })(i);
1364      if (Promise.isPromise(promise)) {
1365        promise.then(resolve, reject);
1366      } else {
1367        resolve(promise);
1368      }
1369    }
1370    return deferred;
1371  };
1372
1373  /**
1374   * Checks if the value is likely a promise (has a 'then' function).
1375   * @return {boolean} true if value is thenable
1376   */
1377  Promise.isPromise = function Promise_isPromise(value) {
1378    return value && typeof value.then === 'function';
1379  };
1380
1381  /**
1382   * Creates resolved promise
1383   * @param value resolve value
1384   * @returns {Promise}
1385   */
1386  Promise.resolve = function Promise_resolve(value) {
1387    return new Promise(function (resolve) { resolve(value); });
1388  };
1389
1390  /**
1391   * Creates rejected promise
1392   * @param reason rejection value
1393   * @returns {Promise}
1394   */
1395  Promise.reject = function Promise_reject(reason) {
1396    return new Promise(function (resolve, reject) { reject(reason); });
1397  };
1398
1399  Promise.prototype = {
1400    _status: null,
1401    _value: null,
1402    _handlers: null,
1403    _unhandledRejection: null,
1404
1405    _updateStatus: function Promise__updateStatus(status, value) {
1406      if (this._status === STATUS_RESOLVED ||
1407          this._status === STATUS_REJECTED) {
1408        return;
1409      }
1410
1411      if (status === STATUS_RESOLVED &&
1412          Promise.isPromise(value)) {
1413        value.then(this._updateStatus.bind(this, STATUS_RESOLVED),
1414                   this._updateStatus.bind(this, STATUS_REJECTED));
1415        return;
1416      }
1417
1418      this._status = status;
1419      this._value = value;
1420
1421      if (status === STATUS_REJECTED && this._handlers.length === 0) {
1422        this._unhandledRejection = true;
1423        HandlerManager.addUnhandledRejection(this);
1424      }
1425
1426      HandlerManager.scheduleHandlers(this);
1427    },
1428
1429    _resolve: function Promise_resolve(value) {
1430      this._updateStatus(STATUS_RESOLVED, value);
1431    },
1432
1433    _reject: function Promise_reject(reason) {
1434      this._updateStatus(STATUS_REJECTED, reason);
1435    },
1436
1437    then: function Promise_then(onResolve, onReject) {
1438      var nextPromise = new Promise(function (resolve, reject) {
1439        this.resolve = resolve;
1440        this.reject = reject;
1441      });
1442      this._handlers.push({
1443        thisPromise: this,
1444        onResolve: onResolve,
1445        onReject: onReject,
1446        nextPromise: nextPromise
1447      });
1448      HandlerManager.scheduleHandlers(this);
1449      return nextPromise;
1450    },
1451

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

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

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

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