|
@@ -28,8 +28,8 @@ factory((root.pdfjsDistBuildPdfCombined = {}));
|
|
|
// Use strict in our context only - users might not want it
|
|
|
'use strict';
|
|
|
|
|
|
-var pdfjsVersion = '1.5.426';
|
|
|
-var pdfjsBuild = '7db1983';
|
|
|
+var pdfjsVersion = '1.5.430';
|
|
|
+var pdfjsBuild = '38c8503';
|
|
|
|
|
|
var pdfjsFilePath =
|
|
|
typeof document !== 'undefined' && document.currentScript ?
|
|
@@ -2443,6 +2443,37 @@ function createPromiseCapability() {
|
|
|
globalScope.Promise = Promise;
|
|
|
})();
|
|
|
|
|
|
+(function WeakMapClosure() {
|
|
|
+ if (globalScope.WeakMap) {
|
|
|
+ return;
|
|
|
+ }
|
|
|
+
|
|
|
+ var id = 0;
|
|
|
+ function WeakMap() {
|
|
|
+ this.id = '$weakmap' + (id++);
|
|
|
+ }
|
|
|
+ WeakMap.prototype = {
|
|
|
+ has: function(obj) {
|
|
|
+ return !!Object.getOwnPropertyDescriptor(obj, this.id);
|
|
|
+ },
|
|
|
+ get: function(obj, defaultValue) {
|
|
|
+ return this.has(obj) ? obj[this.id] : defaultValue;
|
|
|
+ },
|
|
|
+ set: function(obj, value) {
|
|
|
+ Object.defineProperty(obj, this.id, {
|
|
|
+ value: value,
|
|
|
+ enumerable: false,
|
|
|
+ configurable: true
|
|
|
+ });
|
|
|
+ },
|
|
|
+ delete: function(obj) {
|
|
|
+ delete obj[this.id];
|
|
|
+ }
|
|
|
+ };
|
|
|
+
|
|
|
+ globalScope.WeakMap = WeakMap;
|
|
|
+})();
|
|
|
+
|
|
|
var StatTimer = (function StatTimerClosure() {
|
|
|
function rpad(str, pad, length) {
|
|
|
while (str.length < length) {
|
|
@@ -24985,6 +25016,8 @@ var getDefaultSetting = displayDOMUtils.getDefaultSetting;
|
|
|
* initially be set to empty array.
|
|
|
* @property {number} timeout - (optional) Delay in milliseconds before
|
|
|
* rendering of the text runs occurs.
|
|
|
+ * @property {boolean} enhanceTextSelection - (optional) Whether to turn on the
|
|
|
+ * text selection enhancement.
|
|
|
*/
|
|
|
var renderTextLayer = (function renderTextLayerClosure() {
|
|
|
var MAX_TEXT_DIVS_TO_RENDER = 100000;
|
|
@@ -24995,17 +25028,31 @@ var renderTextLayer = (function renderTextLayerClosure() {
|
|
|
return !NonWhitespaceRegexp.test(str);
|
|
|
}
|
|
|
|
|
|
- function appendText(textDivs, viewport, geom, styles, bounds,
|
|
|
- enhanceTextSelection) {
|
|
|
- var style = styles[geom.fontName];
|
|
|
+ function appendText(task, geom, styles) {
|
|
|
+ // Initialize all used properties to keep the caches monomorphic.
|
|
|
var textDiv = document.createElement('div');
|
|
|
- textDivs.push(textDiv);
|
|
|
+ var textDivProperties = {
|
|
|
+ angle: 0,
|
|
|
+ canvasWidth: 0,
|
|
|
+ isWhitespace: false,
|
|
|
+ originalTransform: '',
|
|
|
+ paddingBottom: 0,
|
|
|
+ paddingLeft: 0,
|
|
|
+ paddingRight: 0,
|
|
|
+ paddingTop: 0,
|
|
|
+ scale: 1,
|
|
|
+ };
|
|
|
+
|
|
|
+ task._textDivs.push(textDiv);
|
|
|
if (isAllWhitespace(geom.str)) {
|
|
|
- textDiv.dataset.isWhitespace = true;
|
|
|
+ textDivProperties.isWhitespace = true;
|
|
|
+ task._textDivProperties.set(textDiv, textDivProperties);
|
|
|
return;
|
|
|
}
|
|
|
- var tx = Util.transform(viewport.transform, geom.transform);
|
|
|
+
|
|
|
+ var tx = 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;
|
|
|
}
|
|
@@ -25034,32 +25081,34 @@ var renderTextLayer = (function renderTextLayerClosure() {
|
|
|
textDiv.textContent = geom.str;
|
|
|
// |fontName| is only used by the Font Inspector. This test will succeed
|
|
|
// when e.g. the Font Inspector is off but the Stepper is on, but it's
|
|
|
- // not worth the effort to do a more accurate test.
|
|
|
+ // not worth the effort to do a more accurate test. We only use `dataset`
|
|
|
+ // here to make the font name available for the debugger.
|
|
|
if (getDefaultSetting('pdfBug')) {
|
|
|
textDiv.dataset.fontName = geom.fontName;
|
|
|
}
|
|
|
- // Storing into dataset will convert number into string.
|
|
|
if (angle !== 0) {
|
|
|
- textDiv.dataset.angle = angle * (180 / Math.PI);
|
|
|
+ textDivProperties.angle = angle * (180 / Math.PI);
|
|
|
}
|
|
|
// We don't bother scaling single-char text divs, because it has very
|
|
|
// little effect on text highlighting. This makes scrolling on docs with
|
|
|
// lots of such divs a lot faster.
|
|
|
if (geom.str.length > 1) {
|
|
|
if (style.vertical) {
|
|
|
- textDiv.dataset.canvasWidth = geom.height * viewport.scale;
|
|
|
+ textDivProperties.canvasWidth = geom.height * task._viewport.scale;
|
|
|
} else {
|
|
|
- textDiv.dataset.canvasWidth = geom.width * viewport.scale;
|
|
|
+ textDivProperties.canvasWidth = geom.width * task._viewport.scale;
|
|
|
}
|
|
|
}
|
|
|
- if (enhanceTextSelection) {
|
|
|
+ task._textDivProperties.set(textDiv, textDivProperties);
|
|
|
+
|
|
|
+ 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) *
|
|
|
- viewport.scale;
|
|
|
+ task._viewport.scale;
|
|
|
var divHeight = fontHeight;
|
|
|
|
|
|
var m, b;
|
|
@@ -25070,7 +25119,7 @@ var renderTextLayer = (function renderTextLayerClosure() {
|
|
|
b = [left, top, left + divWidth, top + divHeight];
|
|
|
}
|
|
|
|
|
|
- bounds.push({
|
|
|
+ task._bounds.push({
|
|
|
left: b[0],
|
|
|
top: b[1],
|
|
|
right: b[2],
|
|
@@ -25106,7 +25155,8 @@ var renderTextLayer = (function renderTextLayerClosure() {
|
|
|
var lastFontFamily;
|
|
|
for (var i = 0; i < textDivsLength; i++) {
|
|
|
var textDiv = textDivs[i];
|
|
|
- if (textDiv.dataset.isWhitespace !== undefined) {
|
|
|
+ var textDivProperties = task._textDivProperties.get(textDiv);
|
|
|
+ if (textDivProperties.isWhitespace) {
|
|
|
continue;
|
|
|
}
|
|
|
|
|
@@ -25121,39 +25171,40 @@ var renderTextLayer = (function renderTextLayerClosure() {
|
|
|
}
|
|
|
|
|
|
var width = ctx.measureText(textDiv.textContent).width;
|
|
|
- textDiv.dataset.originalWidth = width;
|
|
|
textLayerFrag.appendChild(textDiv);
|
|
|
|
|
|
- var transform;
|
|
|
- if (textDiv.dataset.canvasWidth !== undefined && width > 0) {
|
|
|
- // Dataset values are of type string.
|
|
|
- var textScale = textDiv.dataset.canvasWidth / width;
|
|
|
- transform = 'scaleX(' + textScale + ')';
|
|
|
- } else {
|
|
|
- transform = '';
|
|
|
+ var transform = '';
|
|
|
+ if (textDivProperties.canvasWidth !== 0 && width > 0) {
|
|
|
+ textDivProperties.scale = textDivProperties.canvasWidth / width;
|
|
|
+ transform = 'scaleX(' + textDivProperties.scale + ')';
|
|
|
}
|
|
|
- var rotation = textDiv.dataset.angle;
|
|
|
- if (rotation) {
|
|
|
- transform = 'rotate(' + rotation + 'deg) ' + transform;
|
|
|
+ if (textDivProperties.angle !== 0) {
|
|
|
+ transform = 'rotate(' + textDivProperties.angle + 'deg) ' + transform;
|
|
|
}
|
|
|
- if (transform) {
|
|
|
- textDiv.dataset.originalTransform = transform;
|
|
|
- CustomStyle.setProp('transform' , textDiv, transform);
|
|
|
+ if (transform !== '') {
|
|
|
+ textDivProperties.originalTransform = transform;
|
|
|
+ CustomStyle.setProp('transform', textDiv, transform);
|
|
|
}
|
|
|
+ task._textDivProperties.set(textDiv, textDivProperties);
|
|
|
}
|
|
|
task._renderingDone = true;
|
|
|
capability.resolve();
|
|
|
}
|
|
|
|
|
|
- function expand(bounds, viewport) {
|
|
|
+ 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;
|
|
|
- if (!div.dataset.angle) {
|
|
|
- div.dataset.paddingLeft = bounds[i].left - expanded[i].left;
|
|
|
- div.dataset.paddingTop = bounds[i].top - expanded[i].top;
|
|
|
- div.dataset.paddingRight = expanded[i].right - bounds[i].right;
|
|
|
- div.dataset.paddingBottom = expanded[i].bottom - bounds[i].bottom;
|
|
|
+ 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;
|
|
|
}
|
|
|
// Box is rotated -- trying to find padding so rotated div will not
|
|
@@ -25198,10 +25249,11 @@ var renderTextLayer = (function renderTextLayerClosure() {
|
|
|
// Not based on math, but to simplify calculations, using cos and sin
|
|
|
// absolute values to not exceed the box (it can but insignificantly).
|
|
|
var boxScale = 1 + Math.min(Math.abs(c), Math.abs(s));
|
|
|
- div.dataset.paddingLeft = findPositiveMin(ts, 32, 16) / boxScale;
|
|
|
- div.dataset.paddingTop = findPositiveMin(ts, 48, 16) / boxScale;
|
|
|
- div.dataset.paddingRight = findPositiveMin(ts, 0, 16) / boxScale;
|
|
|
- div.dataset.paddingBottom = findPositiveMin(ts, 16, 16) / boxScale;
|
|
|
+ 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);
|
|
|
}
|
|
|
}
|
|
|
|
|
@@ -25423,8 +25475,8 @@ var renderTextLayer = (function renderTextLayerClosure() {
|
|
|
this._textContent = textContent;
|
|
|
this._container = container;
|
|
|
this._viewport = viewport;
|
|
|
- textDivs = textDivs || [];
|
|
|
- this._textDivs = textDivs;
|
|
|
+ this._textDivs = textDivs || [];
|
|
|
+ this._textDivProperties = new WeakMap();
|
|
|
this._renderingDone = false;
|
|
|
this._canceled = false;
|
|
|
this._capability = createPromiseCapability();
|
|
@@ -25449,15 +25501,9 @@ var renderTextLayer = (function renderTextLayerClosure() {
|
|
|
|
|
|
_render: function TextLayer_render(timeout) {
|
|
|
var textItems = this._textContent.items;
|
|
|
- var styles = this._textContent.styles;
|
|
|
- var textDivs = this._textDivs;
|
|
|
- var viewport = this._viewport;
|
|
|
- var bounds = this._bounds;
|
|
|
- var enhanceTextSelection = this._enhanceTextSelection;
|
|
|
-
|
|
|
+ var textStyles = this._textContent.styles;
|
|
|
for (var i = 0, len = textItems.length; i < len; i++) {
|
|
|
- appendText(textDivs, viewport, textItems[i], styles, bounds,
|
|
|
- enhanceTextSelection);
|
|
|
+ appendText(this, textItems[i], textStyles);
|
|
|
}
|
|
|
|
|
|
if (!timeout) { // Render right away
|
|
@@ -25476,59 +25522,53 @@ var renderTextLayer = (function renderTextLayerClosure() {
|
|
|
return;
|
|
|
}
|
|
|
if (!this._expanded) {
|
|
|
- expand(this._bounds, this._viewport);
|
|
|
+ expand(this);
|
|
|
this._expanded = true;
|
|
|
this._bounds.length = 0;
|
|
|
}
|
|
|
- if (expandDivs) {
|
|
|
- for (var i = 0, ii = this._textDivs.length; i < ii; i++) {
|
|
|
- var div = this._textDivs[i];
|
|
|
- var transform;
|
|
|
- var width = div.dataset.originalWidth;
|
|
|
- if (div.dataset.canvasWidth !== undefined && width > 0) {
|
|
|
- // Dataset values are of type string.
|
|
|
- var textScale = div.dataset.canvasWidth / width;
|
|
|
- transform = 'scaleX(' + textScale + ')';
|
|
|
- } else {
|
|
|
- transform = '';
|
|
|
+
|
|
|
+ for (var i = 0, ii = this._textDivs.length; i < ii; i++) {
|
|
|
+ var div = this._textDivs[i];
|
|
|
+ var divProperties = this._textDivProperties.get(div);
|
|
|
+
|
|
|
+ if (expandDivs) {
|
|
|
+ var transform = '';
|
|
|
+
|
|
|
+ if (divProperties.scale !== 1) {
|
|
|
+ transform = 'scaleX(' + divProperties.scale + ')';
|
|
|
}
|
|
|
- var rotation = div.dataset.angle;
|
|
|
- if (rotation) {
|
|
|
- transform = 'rotate(' + rotation + 'deg) ' + transform;
|
|
|
+ if (divProperties.angle !== 0) {
|
|
|
+ transform = 'rotate(' + divProperties.angle + 'deg) ' + transform;
|
|
|
}
|
|
|
- if (div.dataset.paddingLeft) {
|
|
|
+ if (divProperties.paddingLeft !== 0) {
|
|
|
div.style.paddingLeft =
|
|
|
- (div.dataset.paddingLeft / textScale) + 'px';
|
|
|
+ (divProperties.paddingLeft / divProperties.scale) + 'px';
|
|
|
transform += ' translateX(' +
|
|
|
- (-div.dataset.paddingLeft / textScale) + 'px)';
|
|
|
+ (-divProperties.paddingLeft / divProperties.scale) + 'px)';
|
|
|
}
|
|
|
- if (div.dataset.paddingTop) {
|
|
|
- div.style.paddingTop = div.dataset.paddingTop + 'px';
|
|
|
- transform += ' translateY(' + (-div.dataset.paddingTop) + 'px)';
|
|
|
+ if (divProperties.paddingTop !== 0) {
|
|
|
+ div.style.paddingTop = divProperties.paddingTop + 'px';
|
|
|
+ transform += ' translateY(' + (-divProperties.paddingTop) + 'px)';
|
|
|
}
|
|
|
- if (div.dataset.paddingRight) {
|
|
|
+ if (divProperties.paddingRight !== 0) {
|
|
|
div.style.paddingRight =
|
|
|
- div.dataset.paddingRight / textScale + 'px';
|
|
|
+ (divProperties.paddingRight / divProperties.scale) + 'px';
|
|
|
}
|
|
|
- if (div.dataset.paddingBottom) {
|
|
|
- div.style.paddingBottom = div.dataset.paddingBottom + 'px';
|
|
|
+ if (divProperties.paddingBottom !== 0) {
|
|
|
+ div.style.paddingBottom = divProperties.paddingBottom + 'px';
|
|
|
}
|
|
|
- if (transform) {
|
|
|
- CustomStyle.setProp('transform' , div, transform);
|
|
|
+ if (transform !== '') {
|
|
|
+ CustomStyle.setProp('transform', div, transform);
|
|
|
}
|
|
|
- }
|
|
|
- } else {
|
|
|
- for (i = 0, ii = this._textDivs.length; i < ii; i++) {
|
|
|
- div = this._textDivs[i];
|
|
|
+ } else {
|
|
|
div.style.padding = 0;
|
|
|
- transform = div.dataset.originalTransform || '';
|
|
|
- CustomStyle.setProp('transform', div, transform);
|
|
|
+ CustomStyle.setProp('transform', div,
|
|
|
+ divProperties.originalTransform);
|
|
|
}
|
|
|
}
|
|
|
},
|
|
|
};
|
|
|
|
|
|
-
|
|
|
/**
|
|
|
* Starts rendering of the text layer.
|
|
|
*
|