pdfjs-dist 2.0.550 → 2.3.200

package/lib/display/text_layer.js

@@ -2,7 +2,7 @@
  * @licstart The following is the entire license notice for the
  * Javascript code in this page
  *
- * Copyright 2017 Mozilla Foundation
+ * Copyright 2019 Mozilla Foundation
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,32 +19,30 @@
  * @licend The above is the entire license notice for the
  * Javascript code in this page
  */
-'use strict';
+"use strict";
 
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.renderTextLayer = undefined;
+exports.renderTextLayer = void 0;
 
-var _util = require('../shared/util');
+var _util = require("../shared/util");
 
-var _global_scope = require('../shared/global_scope');
+var _global_scope = _interopRequireDefault(require("../shared/global_scope"));
 
-var _global_scope2 = _interopRequireDefault(_global_scope);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
 
 var renderTextLayer = function renderTextLayerClosure() {
   var MAX_TEXT_DIVS_TO_RENDER = 100000;
   var NonWhitespaceRegexp = /\S/;
+
   function isAllWhitespace(str) {
     return !NonWhitespaceRegexp.test(str);
   }
-  var styleBuf = ['left: ', 0, 'px; top: ', 0, 'px; font-size: ', 0, 'px; font-family: ', '', ';'];
+
   function appendText(task, geom, styles) {
-    var textDiv = document.createElement('div');
+    var textDiv = document.createElement('span');
     var textDivProperties = {
-      style: null,
       angle: 0,
       canvasWidth: 0,
       isWhitespace: false,
@@ -55,27 +53,37 @@ var renderTextLayer = function renderTextLayerClosure() {
       paddingTop: 0,
       scale: 1
     };
+
     task._textDivs.push(textDiv);
+
     if (isAllWhitespace(geom.str)) {
       textDivProperties.isWhitespace = true;
+
       task._textDivProperties.set(textDiv, textDivProperties);
+
       return;
     }
+
     var tx = _util.Util.transform(task._viewport.transform, geom.transform);
+
     var angle = Math.atan2(tx[1], tx[0]);
     var style = styles[geom.fontName];
+
     if (style.vertical) {
       angle += Math.PI / 2;
     }
+
     var fontHeight = Math.sqrt(tx[2] * tx[2] + tx[3] * tx[3]);
     var fontAscent = fontHeight;
+
     if (style.ascent) {
       fontAscent = style.ascent * fontAscent;
     } else if (style.descent) {
       fontAscent = (1 + style.descent) * fontAscent;
     }
-    var left;
-    var top;
+
+    var left, top;
+
     if (angle === 0) {
       left = tx[4];
       top = tx[5] - fontAscent;
@@ -83,19 +91,21 @@ var renderTextLayer = function renderTextLayerClosure() {
       left = tx[4] + fontAscent * Math.sin(angle);
       top = tx[5] - fontAscent * Math.cos(angle);
     }
-    styleBuf[1] = left;
-    styleBuf[3] = top;
-    styleBuf[5] = fontHeight;
-    styleBuf[7] = style.fontFamily;
-    textDivProperties.style = styleBuf.join('');
-    textDiv.setAttribute('style', textDivProperties.style);
+
+    textDiv.style.left = "".concat(left, "px");
+    textDiv.style.top = "".concat(top, "px");
+    textDiv.style.fontSize = "".concat(fontHeight, "px");
+    textDiv.style.fontFamily = style.fontFamily;
     textDiv.textContent = geom.str;
+
     if (task._fontInspectorEnabled) {
       textDiv.dataset.fontName = geom.fontName;
     }
+
     if (angle !== 0) {
       textDivProperties.angle = angle * (180 / Math.PI);
     }
+
     if (geom.str.length > 1) {
       if (style.vertical) {
         textDivProperties.canvasWidth = geom.height * task._viewport.scale;
@@ -103,26 +113,33 @@ var renderTextLayer = function renderTextLayerClosure() {
         textDivProperties.canvasWidth = geom.width * task._viewport.scale;
       }
     }
+
     task._textDivProperties.set(textDiv, textDivProperties);
+
     if (task._textContentStream) {
       task._layoutText(textDiv);
     }
+
     if (task._enhanceTextSelection) {
       var angleCos = 1,
           angleSin = 0;
+
       if (angle !== 0) {
         angleCos = Math.cos(angle);
         angleSin = Math.sin(angle);
       }
+
       var divWidth = (style.vertical ? geom.height : geom.width) * task._viewport.scale;
       var divHeight = fontHeight;
       var m, b;
+
       if (angle !== 0) {
         m = [angleCos, angleSin, -angleSin, angleCos, left, top];
         b = _util.Util.getAxialAlignedBoundingBox([0, 0, divWidth, divHeight], m);
       } else {
         b = [left, top, left + divWidth, top + divHeight];
       }
+
       task._bounds.push({
         left: b[0],
         top: b[1],
@@ -134,41 +151,53 @@ var renderTextLayer = function renderTextLayerClosure() {
       });
     }
   }
+
   function render(task) {
     if (task._canceled) {
       return;
     }
+
     var textDivs = task._textDivs;
     var capability = task._capability;
     var textDivsLength = textDivs.length;
+
     if (textDivsLength > MAX_TEXT_DIVS_TO_RENDER) {
       task._renderingDone = true;
       capability.resolve();
       return;
     }
+
     if (!task._textContentStream) {
       for (var i = 0; i < textDivsLength; i++) {
         task._layoutText(textDivs[i]);
       }
     }
+
     task._renderingDone = true;
     capability.resolve();
   }
+
   function expand(task) {
     var bounds = task._bounds;
     var viewport = task._viewport;
     var expanded = expandBounds(viewport.width, viewport.height, bounds);
+
     for (var i = 0; i < expanded.length; i++) {
       var div = bounds[i].div;
+
       var divProperties = task._textDivProperties.get(div);
+
       if (divProperties.angle === 0) {
         divProperties.paddingLeft = bounds[i].left - expanded[i].left;
         divProperties.paddingTop = bounds[i].top - expanded[i].top;
         divProperties.paddingRight = expanded[i].right - bounds[i].right;
         divProperties.paddingBottom = expanded[i].bottom - bounds[i].bottom;
+
         task._textDivProperties.set(div, divProperties);
+
         continue;
       }
+
       var e = expanded[i],
           b = bounds[i];
       var m = b.m,
@@ -178,6 +207,7 @@ var renderTextLayer = function renderTextLayerClosure() {
       var ts = new Float64Array(64);
       points.forEach(function (p, i) {
         var t = _util.Util.applyTransform(p, m);
+
         ts[i + 0] = c && (e.left - t[0]) / c;
         ts[i + 4] = s && (e.top - t[1]) / s;
         ts[i + 8] = c && (e.right - t[0]) / c;
@@ -195,24 +225,31 @@ var renderTextLayer = function renderTextLayerClosure() {
         ts[i + 56] = s && (e.right - t[0]) / s;
         ts[i + 60] = c && (e.bottom - t[1]) / -c;
       });
+
       var findPositiveMin = function findPositiveMin(ts, offset, count) {
         var result = 0;
+
         for (var i = 0; i < count; i++) {
           var t = ts[offset++];
+
           if (t > 0) {
             result = result ? Math.min(t, result) : t;
           }
         }
+
         return result;
       };
+
       var boxScale = 1 + Math.min(Math.abs(c), Math.abs(s));
       divProperties.paddingLeft = findPositiveMin(ts, 32, 16) / boxScale;
       divProperties.paddingTop = findPositiveMin(ts, 48, 16) / boxScale;
       divProperties.paddingRight = findPositiveMin(ts, 0, 16) / boxScale;
       divProperties.paddingBottom = findPositiveMin(ts, 16, 16) / boxScale;
+
       task._textDivProperties.set(div, divProperties);
     }
   }
+
   function expandBounds(width, height, boxes) {
     var bounds = boxes.map(function (box, i) {
       return {
@@ -255,6 +292,7 @@ var renderTextLayer = function renderTextLayerClosure() {
     });
     return expanded;
   }
+
   function expandBoundsLTR(width, bounds) {
     bounds.sort(function (a, b) {
       return a.x1 - b.x1 || a.index - b.index;
@@ -275,21 +313,27 @@ var renderTextLayer = function renderTextLayerClosure() {
     }];
     bounds.forEach(function (boundary) {
       var i = 0;
+
       while (i < horizon.length && horizon[i].end <= boundary.y1) {
         i++;
       }
+
       var j = horizon.length - 1;
+
       while (j >= 0 && horizon[j].start >= boundary.y2) {
         j--;
       }
+
       var horizonPart, affectedBoundary;
       var q,
           k,
           maxXNew = -Infinity;
+
       for (q = i; q <= j; q++) {
         horizonPart = horizon[q];
         affectedBoundary = horizonPart.boundary;
         var xNew;
+
         if (affectedBoundary.x2 > boundary.x1) {
           xNew = affectedBoundary.index > boundary.index ? affectedBoundary.x1New : boundary.x1;
         } else if (affectedBoundary.x2New === undefined) {
@@ -297,14 +341,18 @@ var renderTextLayer = function renderTextLayerClosure() {
         } else {
           xNew = affectedBoundary.x2New;
         }
+
         if (xNew > maxXNew) {
           maxXNew = xNew;
         }
       }
+
       boundary.x1New = maxXNew;
+
       for (q = i; q <= j; q++) {
         horizonPart = horizon[q];
         affectedBoundary = horizonPart.boundary;
+
         if (affectedBoundary.x2New === undefined) {
           if (affectedBoundary.x2 > boundary.x1) {
             if (affectedBoundary.index > boundary.index) {
@@ -317,12 +365,15 @@ var renderTextLayer = function renderTextLayerClosure() {
           affectedBoundary.x2New = Math.max(maxXNew, affectedBoundary.x2);
         }
       }
+
       var changedHorizon = [],
           lastBoundary = null;
+
       for (q = i; q <= j; q++) {
         horizonPart = horizon[q];
         affectedBoundary = horizonPart.boundary;
         var useBoundary = affectedBoundary.x2 > boundary.x2 ? affectedBoundary : boundary;
+
         if (lastBoundary === useBoundary) {
           changedHorizon[changedHorizon.length - 1].end = horizonPart.end;
         } else {
@@ -334,6 +385,7 @@ var renderTextLayer = function renderTextLayerClosure() {
           lastBoundary = useBoundary;
         }
       }
+
       if (horizon[i].start < boundary.y1) {
         changedHorizon[0].start = boundary.y1;
         changedHorizon.unshift({
@@ -342,6 +394,7 @@ var renderTextLayer = function renderTextLayerClosure() {
           boundary: horizon[i].boundary
         });
       }
+
       if (boundary.y2 < horizon[j].end) {
         changedHorizon[changedHorizon.length - 1].end = boundary.y2;
         changedHorizon.push({
@@ -350,36 +403,48 @@ var renderTextLayer = function renderTextLayerClosure() {
           boundary: horizon[j].boundary
         });
       }
+
       for (q = i; q <= j; q++) {
         horizonPart = horizon[q];
         affectedBoundary = horizonPart.boundary;
+
         if (affectedBoundary.x2New !== undefined) {
           continue;
         }
+
         var used = false;
+
         for (k = i - 1; !used && k >= 0 && horizon[k].start >= affectedBoundary.y1; k--) {
           used = horizon[k].boundary === affectedBoundary;
         }
+
         for (k = j + 1; !used && k < horizon.length && horizon[k].end <= affectedBoundary.y2; k++) {
           used = horizon[k].boundary === affectedBoundary;
         }
+
         for (k = 0; !used && k < changedHorizon.length; k++) {
           used = changedHorizon[k].boundary === affectedBoundary;
         }
+
         if (!used) {
           affectedBoundary.x2New = maxXNew;
         }
       }
+
       Array.prototype.splice.apply(horizon, [i, j - i + 1].concat(changedHorizon));
     });
     horizon.forEach(function (horizonPart) {
       var affectedBoundary = horizonPart.boundary;
+
       if (affectedBoundary.x2New === undefined) {
         affectedBoundary.x2New = Math.max(width, affectedBoundary.x2);
       }
     });
   }
+
   function TextLayerRenderTask(_ref) {
+    var _this = this;
+
     var textContent = _ref.textContent,
         textContentStream = _ref.textContentStream,
         container = _ref.container,
@@ -387,7 +452,6 @@ var renderTextLayer = function renderTextLayerClosure() {
         textDivs = _ref.textDivs,
         textContentItemsStr = _ref.textContentItemsStr,
         enhanceTextSelection = _ref.enhanceTextSelection;
-
     this._textContent = textContent;
     this._textContentStream = textContentStream;
     this._container = container;
@@ -395,7 +459,7 @@ var renderTextLayer = function renderTextLayerClosure() {
     this._textDivs = textDivs || [];
     this._textContentItemsStr = textContentItemsStr || [];
     this._enhanceTextSelection = !!enhanceTextSelection;
-    this._fontInspectorEnabled = !!(_global_scope2.default.FontInspector && _global_scope2.default.FontInspector.enabled);
+    this._fontInspectorEnabled = !!(_global_scope["default"].FontInspector && _global_scope["default"].FontInspector.enabled);
     this._reader = null;
     this._layoutTextLastFontSize = null;
     this._layoutTextLastFontFamily = null;
@@ -406,75 +470,110 @@ var renderTextLayer = function renderTextLayerClosure() {
     this._capability = (0, _util.createPromiseCapability)();
     this._renderTimer = null;
     this._bounds = [];
+
+    this._capability.promise["finally"](function () {
+      if (_this._layoutTextCtx) {
+        _this._layoutTextCtx.canvas.width = 0;
+        _this._layoutTextCtx.canvas.height = 0;
+        _this._layoutTextCtx = null;
+      }
+    })["catch"](function () {});
   }
+
   TextLayerRenderTask.prototype = {
     get promise() {
       return this._capability.promise;
     },
+
     cancel: function TextLayer_cancel() {
+      this._canceled = true;
+
       if (this._reader) {
-        this._reader.cancel(new _util.AbortException('text layer task cancelled'));
+        this._reader.cancel(new _util.AbortException('TextLayer task cancelled.'));
+
         this._reader = null;
       }
-      this._canceled = true;
+
       if (this._renderTimer !== null) {
         clearTimeout(this._renderTimer);
         this._renderTimer = null;
       }
-      this._capability.reject('canceled');
+
+      this._capability.reject(new Error('TextLayer task cancelled.'));
     },
     _processItems: function _processItems(items, styleCache) {
       for (var i = 0, len = items.length; i < len; i++) {
         this._textContentItemsStr.push(items[i].str);
+
         appendText(this, items[i], styleCache);
       }
     },
     _layoutText: function _layoutText(textDiv) {
-      var textLayerFrag = this._container;
       var textDivProperties = this._textDivProperties.get(textDiv);
+
       if (textDivProperties.isWhitespace) {
         return;
       }
-      var fontSize = textDiv.style.fontSize;
-      var fontFamily = textDiv.style.fontFamily;
-      if (fontSize !== this._layoutTextLastFontSize || fontFamily !== this._layoutTextLastFontFamily) {
-        this._layoutTextCtx.font = fontSize + ' ' + fontFamily;
-        this._lastFontSize = fontSize;
-        this._lastFontFamily = fontFamily;
-      }
-      var width = this._layoutTextCtx.measureText(textDiv.textContent).width;
+
       var transform = '';
-      if (textDivProperties.canvasWidth !== 0 && width > 0) {
-        textDivProperties.scale = textDivProperties.canvasWidth / width;
-        transform = 'scaleX(' + textDivProperties.scale + ')';
+
+      if (textDivProperties.canvasWidth !== 0) {
+        var _textDiv$style = textDiv.style,
+            fontSize = _textDiv$style.fontSize,
+            fontFamily = _textDiv$style.fontFamily;
+
+        if (fontSize !== this._layoutTextLastFontSize || fontFamily !== this._layoutTextLastFontFamily) {
+          this._layoutTextCtx.font = "".concat(fontSize, " ").concat(fontFamily);
+          this._layoutTextLastFontSize = fontSize;
+          this._layoutTextLastFontFamily = fontFamily;
+        }
+
+        var _this$_layoutTextCtx$ = this._layoutTextCtx.measureText(textDiv.textContent),
+            width = _this$_layoutTextCtx$.width;
+
+        if (width > 0) {
+          textDivProperties.scale = textDivProperties.canvasWidth / width;
+          transform = "scaleX(".concat(textDivProperties.scale, ")");
+        }
       }
+
       if (textDivProperties.angle !== 0) {
-        transform = 'rotate(' + textDivProperties.angle + 'deg) ' + transform;
+        transform = "rotate(".concat(textDivProperties.angle, "deg) ").concat(transform);
       }
-      if (transform !== '') {
-        textDivProperties.originalTransform = transform;
+
+      if (transform.length > 0) {
+        if (this._enhanceTextSelection) {
+          textDivProperties.originalTransform = transform;
+        }
+
         textDiv.style.transform = transform;
       }
+
       this._textDivProperties.set(textDiv, textDivProperties);
-      textLayerFrag.appendChild(textDiv);
-    },
 
+      this._container.appendChild(textDiv);
+    },
     _render: function TextLayer_render(timeout) {
-      var _this = this;
+      var _this2 = this;
 
       var capability = (0, _util.createPromiseCapability)();
       var styleCache = Object.create(null);
       var canvas = document.createElement('canvas');
       canvas.mozOpaque = true;
-      this._layoutTextCtx = canvas.getContext('2d', { alpha: false });
+      this._layoutTextCtx = canvas.getContext('2d', {
+        alpha: false
+      });
+
       if (this._textContent) {
         var textItems = this._textContent.items;
         var textStyles = this._textContent.styles;
+
         this._processItems(textItems, textStyles);
+
         capability.resolve();
       } else if (this._textContentStream) {
         var pump = function pump() {
-          _this._reader.read().then(function (_ref2) {
+          _this2._reader.read().then(function (_ref2) {
             var value = _ref2.value,
                 done = _ref2.done;
 
@@ -482,24 +581,30 @@ var renderTextLayer = function renderTextLayerClosure() {
               capability.resolve();
               return;
             }
-            _util.Util.extendObj(styleCache, value.styles);
-            _this._processItems(value.items, styleCache);
+
+            Object.assign(styleCache, value.styles);
+
+            _this2._processItems(value.items, styleCache);
+
             pump();
           }, capability.reject);
         };
+
         this._reader = this._textContentStream.getReader();
         pump();
       } else {
         throw new Error('Neither "textContent" nor "textContentStream"' + ' parameters specified.');
       }
+
       capability.promise.then(function () {
         styleCache = null;
+
         if (!timeout) {
-          render(_this);
+          render(_this2);
         } else {
-          _this._renderTimer = setTimeout(function () {
-            render(_this);
-            _this._renderTimer = null;
+          _this2._renderTimer = setTimeout(function () {
+            render(_this2);
+            _this2._renderTimer = null;
           }, timeout);
         }
       }, this._capability.reject);
@@ -508,52 +613,76 @@ var renderTextLayer = function renderTextLayerClosure() {
       if (!this._enhanceTextSelection || !this._renderingDone) {
         return;
       }
+
       if (this._bounds !== null) {
         expand(this);
         this._bounds = null;
       }
+
+      var NO_PADDING = '0 0 0 0';
+      var transformBuf = [],
+          paddingBuf = [];
+
       for (var i = 0, ii = this._textDivs.length; i < ii; i++) {
         var div = this._textDivs[i];
-        var divProperties = this._textDivProperties.get(div);
-        if (divProperties.isWhitespace) {
+
+        var divProps = this._textDivProperties.get(div);
+
+        if (divProps.isWhitespace) {
           continue;
         }
+
         if (expandDivs) {
-          var transform = '',
-              padding = '';
-          if (divProperties.scale !== 1) {
-            transform = 'scaleX(' + divProperties.scale + ')';
-          }
-          if (divProperties.angle !== 0) {
-            transform = 'rotate(' + divProperties.angle + 'deg) ' + transform;
+          transformBuf.length = 0;
+          paddingBuf.length = 0;
+
+          if (divProps.originalTransform) {
+            transformBuf.push(divProps.originalTransform);
           }
-          if (divProperties.paddingLeft !== 0) {
-            padding += ' padding-left: ' + divProperties.paddingLeft / divProperties.scale + 'px;';
-            transform += ' translateX(' + -divProperties.paddingLeft / divProperties.scale + 'px)';
+
+          if (divProps.paddingTop > 0) {
+            paddingBuf.push("".concat(divProps.paddingTop, "px"));
+            transformBuf.push("translateY(".concat(-divProps.paddingTop, "px)"));
+          } else {
+            paddingBuf.push(0);
           }
-          if (divProperties.paddingTop !== 0) {
-            padding += ' padding-top: ' + divProperties.paddingTop + 'px;';
-            transform += ' translateY(' + -divProperties.paddingTop + 'px)';
+
+          if (divProps.paddingRight > 0) {
+            paddingBuf.push("".concat(divProps.paddingRight / divProps.scale, "px"));
+          } else {
+            paddingBuf.push(0);
           }
-          if (divProperties.paddingRight !== 0) {
-            padding += ' padding-right: ' + divProperties.paddingRight / divProperties.scale + 'px;';
+
+          if (divProps.paddingBottom > 0) {
+            paddingBuf.push("".concat(divProps.paddingBottom, "px"));
+          } else {
+            paddingBuf.push(0);
           }
-          if (divProperties.paddingBottom !== 0) {
-            padding += ' padding-bottom: ' + divProperties.paddingBottom + 'px;';
+
+          if (divProps.paddingLeft > 0) {
+            paddingBuf.push("".concat(divProps.paddingLeft / divProps.scale, "px"));
+            transformBuf.push("translateX(".concat(-divProps.paddingLeft / divProps.scale, "px)"));
+          } else {
+            paddingBuf.push(0);
           }
-          if (padding !== '') {
-            div.setAttribute('style', divProperties.style + padding);
+
+          var padding = paddingBuf.join(' ');
+
+          if (padding !== NO_PADDING) {
+            div.style.padding = padding;
           }
-          if (transform !== '') {
-            div.style.transform = transform;
+
+          if (transformBuf.length) {
+            div.style.transform = transformBuf.join(' ');
           }
         } else {
-          div.style.padding = 0;
-          div.style.transform = divProperties.originalTransform || '';
+          div.style.padding = null;
+          div.style.transform = divProps.originalTransform;
         }
       }
     }
   };
+
   function renderTextLayer(renderParameters) {
     var task = new TextLayerRenderTask({
       textContent: renderParameters.textContent,
@@ -564,9 +693,13 @@ var renderTextLayer = function renderTextLayerClosure() {
       textContentItemsStr: renderParameters.textContentItemsStr,
       enhanceTextSelection: renderParameters.enhanceTextSelection
     });
+
     task._render(renderParameters.timeout);
+
     return task;
   }
+
   return renderTextLayer;
 }();
+
 exports.renderTextLayer = renderTextLayer;