You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
494 lines
14 KiB
494 lines
14 KiB
/** |
|
* @licstart The following is the entire license notice for the |
|
* Javascript code in this page |
|
* |
|
* Copyright 2018 Mozilla Foundation |
|
* |
|
* Licensed under the Apache License, Version 2.0 (the "License"); |
|
* you may not use this file except in compliance with the License. |
|
* You may obtain a copy of the License at |
|
* |
|
* http://www.apache.org/licenses/LICENSE-2.0 |
|
* |
|
* Unless required by applicable law or agreed to in writing, software |
|
* distributed under the License is distributed on an "AS IS" BASIS, |
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
|
* See the License for the specific language governing permissions and |
|
* limitations under the License. |
|
* |
|
* @licend The above is the entire license notice for the |
|
* Javascript code in this page |
|
*/ |
|
"use strict"; |
|
|
|
Object.defineProperty(exports, "__esModule", { |
|
value: true |
|
}); |
|
exports.addLinkAttributes = addLinkAttributes; |
|
exports.getFilenameFromUrl = getFilenameFromUrl; |
|
exports.loadScript = loadScript; |
|
exports.DummyStatTimer = exports.StatTimer = exports.DOMSVGFactory = exports.DOMCMapReaderFactory = exports.DOMCanvasFactory = exports.DEFAULT_LINK_REL = exports.LinkTarget = exports.RenderingCancelledException = exports.PageViewport = void 0; |
|
|
|
var _util = require("../shared/util"); |
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } } |
|
|
|
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } |
|
|
|
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; } |
|
|
|
var DEFAULT_LINK_REL = 'noopener noreferrer nofollow'; |
|
exports.DEFAULT_LINK_REL = DEFAULT_LINK_REL; |
|
var SVG_NS = 'http://www.w3.org/2000/svg'; |
|
|
|
var DOMCanvasFactory = |
|
/*#__PURE__*/ |
|
function () { |
|
function DOMCanvasFactory() { |
|
_classCallCheck(this, DOMCanvasFactory); |
|
} |
|
|
|
_createClass(DOMCanvasFactory, [{ |
|
key: "create", |
|
value: function create(width, height) { |
|
if (width <= 0 || height <= 0) { |
|
throw new Error('invalid canvas size'); |
|
} |
|
|
|
var canvas = document.createElement('canvas'); |
|
var context = canvas.getContext('2d'); |
|
canvas.width = width; |
|
canvas.height = height; |
|
return { |
|
canvas: canvas, |
|
context: context |
|
}; |
|
} |
|
}, { |
|
key: "reset", |
|
value: function reset(canvasAndContext, width, height) { |
|
if (!canvasAndContext.canvas) { |
|
throw new Error('canvas is not specified'); |
|
} |
|
|
|
if (width <= 0 || height <= 0) { |
|
throw new Error('invalid canvas size'); |
|
} |
|
|
|
canvasAndContext.canvas.width = width; |
|
canvasAndContext.canvas.height = height; |
|
} |
|
}, { |
|
key: "destroy", |
|
value: function destroy(canvasAndContext) { |
|
if (!canvasAndContext.canvas) { |
|
throw new Error('canvas is not specified'); |
|
} |
|
|
|
canvasAndContext.canvas.width = 0; |
|
canvasAndContext.canvas.height = 0; |
|
canvasAndContext.canvas = null; |
|
canvasAndContext.context = null; |
|
} |
|
}]); |
|
|
|
return DOMCanvasFactory; |
|
}(); |
|
|
|
exports.DOMCanvasFactory = DOMCanvasFactory; |
|
|
|
var DOMCMapReaderFactory = |
|
/*#__PURE__*/ |
|
function () { |
|
function DOMCMapReaderFactory(_ref) { |
|
var _ref$baseUrl = _ref.baseUrl, |
|
baseUrl = _ref$baseUrl === void 0 ? null : _ref$baseUrl, |
|
_ref$isCompressed = _ref.isCompressed, |
|
isCompressed = _ref$isCompressed === void 0 ? false : _ref$isCompressed; |
|
|
|
_classCallCheck(this, DOMCMapReaderFactory); |
|
|
|
this.baseUrl = baseUrl; |
|
this.isCompressed = isCompressed; |
|
} |
|
|
|
_createClass(DOMCMapReaderFactory, [{ |
|
key: "fetch", |
|
value: function fetch(_ref2) { |
|
var _this = this; |
|
|
|
var name = _ref2.name; |
|
|
|
if (!this.baseUrl) { |
|
return Promise.reject(new Error('The CMap "baseUrl" parameter must be specified, ensure that ' + 'the "cMapUrl" and "cMapPacked" API parameters are provided.')); |
|
} |
|
|
|
if (!name) { |
|
return Promise.reject(new Error('CMap name must be specified.')); |
|
} |
|
|
|
return new Promise(function (resolve, reject) { |
|
var url = _this.baseUrl + name + (_this.isCompressed ? '.bcmap' : ''); |
|
var request = new XMLHttpRequest(); |
|
request.open('GET', url, true); |
|
|
|
if (_this.isCompressed) { |
|
request.responseType = 'arraybuffer'; |
|
} |
|
|
|
request.onreadystatechange = function () { |
|
if (request.readyState !== XMLHttpRequest.DONE) { |
|
return; |
|
} |
|
|
|
if (request.status === 200 || request.status === 0) { |
|
var data; |
|
|
|
if (_this.isCompressed && request.response) { |
|
data = new Uint8Array(request.response); |
|
} else if (!_this.isCompressed && request.responseText) { |
|
data = (0, _util.stringToBytes)(request.responseText); |
|
} |
|
|
|
if (data) { |
|
resolve({ |
|
cMapData: data, |
|
compressionType: _this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE |
|
}); |
|
return; |
|
} |
|
} |
|
|
|
reject(new Error('Unable to load ' + (_this.isCompressed ? 'binary ' : '') + 'CMap at: ' + url)); |
|
}; |
|
|
|
request.send(null); |
|
}); |
|
} |
|
}]); |
|
|
|
return DOMCMapReaderFactory; |
|
}(); |
|
|
|
exports.DOMCMapReaderFactory = DOMCMapReaderFactory; |
|
|
|
var DOMSVGFactory = |
|
/*#__PURE__*/ |
|
function () { |
|
function DOMSVGFactory() { |
|
_classCallCheck(this, DOMSVGFactory); |
|
} |
|
|
|
_createClass(DOMSVGFactory, [{ |
|
key: "create", |
|
value: function create(width, height) { |
|
(0, _util.assert)(width > 0 && height > 0, 'Invalid SVG dimensions'); |
|
var svg = document.createElementNS(SVG_NS, 'svg:svg'); |
|
svg.setAttribute('version', '1.1'); |
|
svg.setAttribute('width', width + 'px'); |
|
svg.setAttribute('height', height + 'px'); |
|
svg.setAttribute('preserveAspectRatio', 'none'); |
|
svg.setAttribute('viewBox', '0 0 ' + width + ' ' + height); |
|
return svg; |
|
} |
|
}, { |
|
key: "createElement", |
|
value: function createElement(type) { |
|
(0, _util.assert)(typeof type === 'string', 'Invalid SVG element type'); |
|
return document.createElementNS(SVG_NS, type); |
|
} |
|
}]); |
|
|
|
return DOMSVGFactory; |
|
}(); |
|
|
|
exports.DOMSVGFactory = DOMSVGFactory; |
|
|
|
var PageViewport = |
|
/*#__PURE__*/ |
|
function () { |
|
function PageViewport(_ref3) { |
|
var viewBox = _ref3.viewBox, |
|
scale = _ref3.scale, |
|
rotation = _ref3.rotation, |
|
_ref3$offsetX = _ref3.offsetX, |
|
offsetX = _ref3$offsetX === void 0 ? 0 : _ref3$offsetX, |
|
_ref3$offsetY = _ref3.offsetY, |
|
offsetY = _ref3$offsetY === void 0 ? 0 : _ref3$offsetY, |
|
_ref3$dontFlip = _ref3.dontFlip, |
|
dontFlip = _ref3$dontFlip === void 0 ? false : _ref3$dontFlip; |
|
|
|
_classCallCheck(this, PageViewport); |
|
|
|
this.viewBox = viewBox; |
|
this.scale = scale; |
|
this.rotation = rotation; |
|
this.offsetX = offsetX; |
|
this.offsetY = offsetY; |
|
var centerX = (viewBox[2] + viewBox[0]) / 2; |
|
var centerY = (viewBox[3] + viewBox[1]) / 2; |
|
var rotateA, rotateB, rotateC, rotateD; |
|
rotation = rotation % 360; |
|
rotation = rotation < 0 ? rotation + 360 : rotation; |
|
|
|
switch (rotation) { |
|
case 180: |
|
rotateA = -1; |
|
rotateB = 0; |
|
rotateC = 0; |
|
rotateD = 1; |
|
break; |
|
|
|
case 90: |
|
rotateA = 0; |
|
rotateB = 1; |
|
rotateC = 1; |
|
rotateD = 0; |
|
break; |
|
|
|
case 270: |
|
rotateA = 0; |
|
rotateB = -1; |
|
rotateC = -1; |
|
rotateD = 0; |
|
break; |
|
|
|
default: |
|
rotateA = 1; |
|
rotateB = 0; |
|
rotateC = 0; |
|
rotateD = -1; |
|
break; |
|
} |
|
|
|
if (dontFlip) { |
|
rotateC = -rotateC; |
|
rotateD = -rotateD; |
|
} |
|
|
|
var offsetCanvasX, offsetCanvasY; |
|
var width, height; |
|
|
|
if (rotateA === 0) { |
|
offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX; |
|
offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY; |
|
width = Math.abs(viewBox[3] - viewBox[1]) * scale; |
|
height = Math.abs(viewBox[2] - viewBox[0]) * scale; |
|
} else { |
|
offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX; |
|
offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY; |
|
width = Math.abs(viewBox[2] - viewBox[0]) * scale; |
|
height = Math.abs(viewBox[3] - viewBox[1]) * scale; |
|
} |
|
|
|
this.transform = [rotateA * scale, rotateB * scale, rotateC * scale, rotateD * scale, offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY, offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY]; |
|
this.width = width; |
|
this.height = height; |
|
} |
|
|
|
_createClass(PageViewport, [{ |
|
key: "clone", |
|
value: function clone() { |
|
var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {}, |
|
_ref4$scale = _ref4.scale, |
|
scale = _ref4$scale === void 0 ? this.scale : _ref4$scale, |
|
_ref4$rotation = _ref4.rotation, |
|
rotation = _ref4$rotation === void 0 ? this.rotation : _ref4$rotation, |
|
_ref4$dontFlip = _ref4.dontFlip, |
|
dontFlip = _ref4$dontFlip === void 0 ? false : _ref4$dontFlip; |
|
|
|
return new PageViewport({ |
|
viewBox: this.viewBox.slice(), |
|
scale: scale, |
|
rotation: rotation, |
|
offsetX: this.offsetX, |
|
offsetY: this.offsetY, |
|
dontFlip: dontFlip |
|
}); |
|
} |
|
}, { |
|
key: "convertToViewportPoint", |
|
value: function convertToViewportPoint(x, y) { |
|
return _util.Util.applyTransform([x, y], this.transform); |
|
} |
|
}, { |
|
key: "convertToViewportRectangle", |
|
value: function convertToViewportRectangle(rect) { |
|
var tl = _util.Util.applyTransform([rect[0], rect[1]], this.transform); |
|
|
|
var br = _util.Util.applyTransform([rect[2], rect[3]], this.transform); |
|
|
|
return [tl[0], tl[1], br[0], br[1]]; |
|
} |
|
}, { |
|
key: "convertToPdfPoint", |
|
value: function convertToPdfPoint(x, y) { |
|
return _util.Util.applyInverseTransform([x, y], this.transform); |
|
} |
|
}]); |
|
|
|
return PageViewport; |
|
}(); |
|
|
|
exports.PageViewport = PageViewport; |
|
|
|
var RenderingCancelledException = function RenderingCancelledException() { |
|
function RenderingCancelledException(msg, type) { |
|
this.message = msg; |
|
this.type = type; |
|
} |
|
|
|
RenderingCancelledException.prototype = new Error(); |
|
RenderingCancelledException.prototype.name = 'RenderingCancelledException'; |
|
RenderingCancelledException.constructor = RenderingCancelledException; |
|
return RenderingCancelledException; |
|
}(); |
|
|
|
exports.RenderingCancelledException = RenderingCancelledException; |
|
var LinkTarget = { |
|
NONE: 0, |
|
SELF: 1, |
|
BLANK: 2, |
|
PARENT: 3, |
|
TOP: 4 |
|
}; |
|
exports.LinkTarget = LinkTarget; |
|
var LinkTargetStringMap = ['', '_self', '_blank', '_parent', '_top']; |
|
|
|
function addLinkAttributes(link) { |
|
var _ref5 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {}, |
|
url = _ref5.url, |
|
target = _ref5.target, |
|
rel = _ref5.rel; |
|
|
|
link.href = link.title = url ? (0, _util.removeNullCharacters)(url) : ''; |
|
|
|
if (url) { |
|
var LinkTargetValues = Object.values(LinkTarget); |
|
var targetIndex = LinkTargetValues.includes(target) ? target : LinkTarget.NONE; |
|
link.target = LinkTargetStringMap[targetIndex]; |
|
link.rel = typeof rel === 'string' ? rel : DEFAULT_LINK_REL; |
|
} |
|
} |
|
|
|
function getFilenameFromUrl(url) { |
|
var anchor = url.indexOf('#'); |
|
var query = url.indexOf('?'); |
|
var end = Math.min(anchor > 0 ? anchor : url.length, query > 0 ? query : url.length); |
|
return url.substring(url.lastIndexOf('/', end) + 1, end); |
|
} |
|
|
|
var StatTimer = |
|
/*#__PURE__*/ |
|
function () { |
|
function StatTimer() { |
|
var enable = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true; |
|
|
|
_classCallCheck(this, StatTimer); |
|
|
|
this.enabled = !!enable; |
|
this.started = Object.create(null); |
|
this.times = []; |
|
} |
|
|
|
_createClass(StatTimer, [{ |
|
key: "time", |
|
value: function time(name) { |
|
if (!this.enabled) { |
|
return; |
|
} |
|
|
|
if (name in this.started) { |
|
(0, _util.warn)('Timer is already running for ' + name); |
|
} |
|
|
|
this.started[name] = Date.now(); |
|
} |
|
}, { |
|
key: "timeEnd", |
|
value: function timeEnd(name) { |
|
if (!this.enabled) { |
|
return; |
|
} |
|
|
|
if (!(name in this.started)) { |
|
(0, _util.warn)('Timer has not been started for ' + name); |
|
} |
|
|
|
this.times.push({ |
|
'name': name, |
|
'start': this.started[name], |
|
'end': Date.now() |
|
}); |
|
delete this.started[name]; |
|
} |
|
}, { |
|
key: "toString", |
|
value: function toString() { |
|
var times = this.times; |
|
var out = '', |
|
longest = 0; |
|
|
|
for (var i = 0, ii = times.length; i < ii; ++i) { |
|
var name = times[i]['name']; |
|
|
|
if (name.length > longest) { |
|
longest = name.length; |
|
} |
|
} |
|
|
|
for (var _i = 0, _ii = times.length; _i < _ii; ++_i) { |
|
var span = times[_i]; |
|
var duration = span.end - span.start; |
|
out += "".concat(span['name'].padEnd(longest), " ").concat(duration, "ms\n"); |
|
} |
|
|
|
return out; |
|
} |
|
}]); |
|
|
|
return StatTimer; |
|
}(); |
|
|
|
exports.StatTimer = StatTimer; |
|
|
|
var DummyStatTimer = |
|
/*#__PURE__*/ |
|
function () { |
|
function DummyStatTimer() { |
|
_classCallCheck(this, DummyStatTimer); |
|
|
|
(0, _util.unreachable)('Cannot initialize DummyStatTimer.'); |
|
} |
|
|
|
_createClass(DummyStatTimer, null, [{ |
|
key: "time", |
|
value: function time(name) {} |
|
}, { |
|
key: "timeEnd", |
|
value: function timeEnd(name) {} |
|
}, { |
|
key: "toString", |
|
value: function toString() { |
|
return ''; |
|
} |
|
}]); |
|
|
|
return DummyStatTimer; |
|
}(); |
|
|
|
exports.DummyStatTimer = DummyStatTimer; |
|
|
|
function loadScript(src) { |
|
return new Promise(function (resolve, reject) { |
|
var script = document.createElement('script'); |
|
script.src = src; |
|
script.onload = resolve; |
|
|
|
script.onerror = function () { |
|
reject(new Error("Cannot load script at: ".concat(script.src))); |
|
}; |
|
|
|
(document.head || document.documentElement).appendChild(script); |
|
}); |
|
} |