pdfjs-dist-es5
Version:
Generic build of Mozilla's PDF.js library.(es5-version)
1,338 lines (1,129 loc) • 585 kB
JavaScript
'use strict'
function _classStaticPrivateMethodGet (receiver, classConstructor, method) { _classCheckPrivateStaticAccess(receiver, classConstructor); return method }
function _classCheckPrivateStaticAccess (receiver, classConstructor) { if (receiver !== classConstructor) { throw new TypeError('Private static access of wrong provenance') } }
function _defineProperty (obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }) } else { obj[key] = value } return obj }
function _classPrivateMethodInitSpec (obj, privateSet) { _checkPrivateRedeclaration(obj, privateSet); privateSet.add(obj) }
function _classPrivateMethodGet (receiver, privateSet, fn) { if (!privateSet.has(receiver)) { throw new TypeError('attempted to get private field on non-instance') } return fn }
function _classPrivateFieldInitSpec (obj, privateMap, value) { _checkPrivateRedeclaration(obj, privateMap); privateMap.set(obj, value) }
function _checkPrivateRedeclaration (obj, privateCollection) { if (privateCollection.has(obj)) { throw new TypeError('Cannot initialize the same private elements twice on an object') } }
function _classPrivateFieldSet (receiver, privateMap, value) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, 'set'); _classApplyDescriptorSet(receiver, descriptor, value); return value }
function _classApplyDescriptorSet (receiver, descriptor, value) { if (descriptor.set) { descriptor.set.call(receiver, value) } else { if (!descriptor.writable) { throw new TypeError('attempted to set read only private field') } descriptor.value = value } }
function _classPrivateFieldGet (receiver, privateMap) { var descriptor = _classExtractFieldDescriptor(receiver, privateMap, 'get'); return _classApplyDescriptorGet(receiver, descriptor) }
function _classExtractFieldDescriptor (receiver, privateMap, action) { if (!privateMap.has(receiver)) { throw new TypeError('attempted to ' + action + ' private field on non-instance') } return privateMap.get(receiver) }
function _classApplyDescriptorGet (receiver, descriptor) { if (descriptor.get) { return descriptor.get.call(receiver) } return descriptor.value }
/**
* @licstart The following is the entire license notice for the
* Javascript code in this page
*
* Copyright 2022 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
*/
(function webpackUniversalModuleDefinition (root, factory) {
if (typeof exports === 'object' && typeof module === 'object') module.exports = factory();else if (typeof define === 'function' && define.amd) define('pdfjs-dist/build/pdf', [], factory);else if (typeof exports === 'object') exports['pdfjs-dist/build/pdf'] = factory();else root['pdfjs-dist/build/pdf'] = root.pdfjsLib = factory()
})(void 0, function () {
return (
/******/
(() => {
// webpackBootstrap
/******/
'use strict'
/******/
var __webpack_modules__ = [
/* 0 */
,
/* 1 */
/***/
(__unused_webpack_module, exports, __w_pdfjs_require__) => {
Object.defineProperty(exports, '__esModule', {
value: true
})
exports.VerbosityLevel = exports.Util = exports.UnknownErrorException = exports.UnexpectedResponseException = exports.UNSUPPORTED_FEATURES = exports.TextRenderingMode = exports.StreamType = exports.RenderingIntentFlag = exports.PermissionFlag = exports.PasswordResponses = exports.PasswordException = exports.PageActionEventType = exports.OPS = exports.MissingPDFException = exports.IsLittleEndianCached = exports.IsEvalSupportedCached = exports.InvalidPDFException = exports.ImageKind = exports.IDENTITY_MATRIX = exports.FormatError = exports.FontType = exports.FONT_IDENTITY_MATRIX = exports.DocumentActionEventType = exports.CMapCompressionType = exports.BaseException = exports.AnnotationType = exports.AnnotationStateModelType = exports.AnnotationReviewState = exports.AnnotationReplyType = exports.AnnotationMode = exports.AnnotationMarkedState = exports.AnnotationFlag = exports.AnnotationFieldFlag = exports.AnnotationBorderStyleType = exports.AnnotationActionEventType = exports.AbortException = void 0
exports.arrayByteLength = arrayByteLength
exports.arraysToBytes = arraysToBytes
exports.assert = assert
exports.bytesToString = bytesToString
exports.createPromiseCapability = createPromiseCapability
exports.createValidAbsoluteUrl = createValidAbsoluteUrl
exports.escapeString = escapeString
exports.getModificationDate = getModificationDate
exports.getVerbosityLevel = getVerbosityLevel
exports.info = info
exports.isArrayBuffer = isArrayBuffer
exports.isArrayEqual = isArrayEqual
exports.isAscii = isAscii
exports.isSameOrigin = isSameOrigin
exports.objectFromMap = objectFromMap
exports.objectSize = objectSize
exports.setVerbosityLevel = setVerbosityLevel
exports.shadow = shadow
exports.string32 = string32
exports.stringToBytes = stringToBytes
exports.stringToPDFString = stringToPDFString
exports.stringToUTF16BEString = stringToUTF16BEString
exports.stringToUTF8String = stringToUTF8String
exports.unreachable = unreachable
exports.utf8StringToString = utf8StringToString
exports.warn = warn
__w_pdfjs_require__(2)
const IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0]
exports.IDENTITY_MATRIX = IDENTITY_MATRIX
const FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0]
exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX
const RenderingIntentFlag = {
ANY: 0x01,
DISPLAY: 0x02,
PRINT: 0x04,
ANNOTATIONS_FORMS: 0x10,
ANNOTATIONS_STORAGE: 0x20,
ANNOTATIONS_DISABLE: 0x40,
OPLIST: 0x100
}
exports.RenderingIntentFlag = RenderingIntentFlag
const AnnotationMode = {
DISABLE: 0,
ENABLE: 1,
ENABLE_FORMS: 2,
ENABLE_STORAGE: 3
}
exports.AnnotationMode = AnnotationMode
const PermissionFlag = {
PRINT: 0x04,
MODIFY_CONTENTS: 0x08,
COPY: 0x10,
MODIFY_ANNOTATIONS: 0x20,
FILL_INTERACTIVE_FORMS: 0x100,
COPY_FOR_ACCESSIBILITY: 0x200,
ASSEMBLE: 0x400,
PRINT_HIGH_QUALITY: 0x800
}
exports.PermissionFlag = PermissionFlag
const TextRenderingMode = {
FILL: 0,
STROKE: 1,
FILL_STROKE: 2,
INVISIBLE: 3,
FILL_ADD_TO_PATH: 4,
STROKE_ADD_TO_PATH: 5,
FILL_STROKE_ADD_TO_PATH: 6,
ADD_TO_PATH: 7,
FILL_STROKE_MASK: 3,
ADD_TO_PATH_FLAG: 4
}
exports.TextRenderingMode = TextRenderingMode
const ImageKind = {
GRAYSCALE_1BPP: 1,
RGB_24BPP: 2,
RGBA_32BPP: 3
}
exports.ImageKind = ImageKind
const AnnotationType = {
TEXT: 1,
LINK: 2,
FREETEXT: 3,
LINE: 4,
SQUARE: 5,
CIRCLE: 6,
POLYGON: 7,
POLYLINE: 8,
HIGHLIGHT: 9,
UNDERLINE: 10,
SQUIGGLY: 11,
STRIKEOUT: 12,
STAMP: 13,
CARET: 14,
INK: 15,
POPUP: 16,
FILEATTACHMENT: 17,
SOUND: 18,
MOVIE: 19,
WIDGET: 20,
SCREEN: 21,
PRINTERMARK: 22,
TRAPNET: 23,
WATERMARK: 24,
THREED: 25,
REDACT: 26
}
exports.AnnotationType = AnnotationType
const AnnotationStateModelType = {
MARKED: 'Marked',
REVIEW: 'Review'
}
exports.AnnotationStateModelType = AnnotationStateModelType
const AnnotationMarkedState = {
MARKED: 'Marked',
UNMARKED: 'Unmarked'
}
exports.AnnotationMarkedState = AnnotationMarkedState
const AnnotationReviewState = {
ACCEPTED: 'Accepted',
REJECTED: 'Rejected',
CANCELLED: 'Cancelled',
COMPLETED: 'Completed',
NONE: 'None'
}
exports.AnnotationReviewState = AnnotationReviewState
const AnnotationReplyType = {
GROUP: 'Group',
REPLY: 'R'
}
exports.AnnotationReplyType = AnnotationReplyType
const AnnotationFlag = {
INVISIBLE: 0x01,
HIDDEN: 0x02,
PRINT: 0x04,
NOZOOM: 0x08,
NOROTATE: 0x10,
NOVIEW: 0x20,
READONLY: 0x40,
LOCKED: 0x80,
TOGGLENOVIEW: 0x100,
LOCKEDCONTENTS: 0x200
}
exports.AnnotationFlag = AnnotationFlag
const AnnotationFieldFlag = {
READONLY: 0x0000001,
REQUIRED: 0x0000002,
NOEXPORT: 0x0000004,
MULTILINE: 0x0001000,
PASSWORD: 0x0002000,
NOTOGGLETOOFF: 0x0004000,
RADIO: 0x0008000,
PUSHBUTTON: 0x0010000,
COMBO: 0x0020000,
EDIT: 0x0040000,
SORT: 0x0080000,
FILESELECT: 0x0100000,
MULTISELECT: 0x0200000,
DONOTSPELLCHECK: 0x0400000,
DONOTSCROLL: 0x0800000,
COMB: 0x1000000,
RICHTEXT: 0x2000000,
RADIOSINUNISON: 0x2000000,
COMMITONSELCHANGE: 0x4000000
}
exports.AnnotationFieldFlag = AnnotationFieldFlag
const AnnotationBorderStyleType = {
SOLID: 1,
DASHED: 2,
BEVELED: 3,
INSET: 4,
UNDERLINE: 5
}
exports.AnnotationBorderStyleType = AnnotationBorderStyleType
const AnnotationActionEventType = {
E: 'Mouse Enter',
X: 'Mouse Exit',
D: 'Mouse Down',
U: 'Mouse Up',
Fo: 'Focus',
Bl: 'Blur',
PO: 'PageOpen',
PC: 'PageClose',
PV: 'PageVisible',
PI: 'PageInvisible',
K: 'Keystroke',
F: 'Format',
V: 'Validate',
C: 'Calculate'
}
exports.AnnotationActionEventType = AnnotationActionEventType
const DocumentActionEventType = {
WC: 'WillClose',
WS: 'WillSave',
DS: 'DidSave',
WP: 'WillPrint',
DP: 'DidPrint'
}
exports.DocumentActionEventType = DocumentActionEventType
const PageActionEventType = {
O: 'PageOpen',
C: 'PageClose'
}
exports.PageActionEventType = PageActionEventType
const StreamType = {
UNKNOWN: 'UNKNOWN',
FLATE: 'FLATE',
LZW: 'LZW',
DCT: 'DCT',
JPX: 'JPX',
JBIG: 'JBIG',
A85: 'A85',
AHX: 'AHX',
CCF: 'CCF',
RLX: 'RLX'
}
exports.StreamType = StreamType
const FontType = {
UNKNOWN: 'UNKNOWN',
TYPE1: 'TYPE1',
TYPE1STANDARD: 'TYPE1STANDARD',
TYPE1C: 'TYPE1C',
CIDFONTTYPE0: 'CIDFONTTYPE0',
CIDFONTTYPE0C: 'CIDFONTTYPE0C',
TRUETYPE: 'TRUETYPE',
CIDFONTTYPE2: 'CIDFONTTYPE2',
TYPE3: 'TYPE3',
OPENTYPE: 'OPENTYPE',
TYPE0: 'TYPE0',
MMTYPE1: 'MMTYPE1'
}
exports.FontType = FontType
const VerbosityLevel = {
ERRORS: 0,
WARNINGS: 1,
INFOS: 5
}
exports.VerbosityLevel = VerbosityLevel
const CMapCompressionType = {
NONE: 0,
BINARY: 1,
STREAM: 2
}
exports.CMapCompressionType = CMapCompressionType
const OPS = {
dependency: 1,
setLineWidth: 2,
setLineCap: 3,
setLineJoin: 4,
setMiterLimit: 5,
setDash: 6,
setRenderingIntent: 7,
setFlatness: 8,
setGState: 9,
save: 10,
restore: 11,
transform: 12,
moveTo: 13,
lineTo: 14,
curveTo: 15,
curveTo2: 16,
curveTo3: 17,
closePath: 18,
rectangle: 19,
stroke: 20,
closeStroke: 21,
fill: 22,
eoFill: 23,
fillStroke: 24,
eoFillStroke: 25,
closeFillStroke: 26,
closeEOFillStroke: 27,
endPath: 28,
clip: 29,
eoClip: 30,
beginText: 31,
endText: 32,
setCharSpacing: 33,
setWordSpacing: 34,
setHScale: 35,
setLeading: 36,
setFont: 37,
setTextRenderingMode: 38,
setTextRise: 39,
moveText: 40,
setLeadingMoveText: 41,
setTextMatrix: 42,
nextLine: 43,
showText: 44,
showSpacedText: 45,
nextLineShowText: 46,
nextLineSetSpacingShowText: 47,
setCharWidth: 48,
setCharWidthAndBounds: 49,
setStrokeColorSpace: 50,
setFillColorSpace: 51,
setStrokeColor: 52,
setStrokeColorN: 53,
setFillColor: 54,
setFillColorN: 55,
setStrokeGray: 56,
setFillGray: 57,
setStrokeRGBColor: 58,
setFillRGBColor: 59,
setStrokeCMYKColor: 60,
setFillCMYKColor: 61,
shadingFill: 62,
beginInlineImage: 63,
beginImageData: 64,
endInlineImage: 65,
paintXObject: 66,
markPoint: 67,
markPointProps: 68,
beginMarkedContent: 69,
beginMarkedContentProps: 70,
endMarkedContent: 71,
beginCompat: 72,
endCompat: 73,
paintFormXObjectBegin: 74,
paintFormXObjectEnd: 75,
beginGroup: 76,
endGroup: 77,
beginAnnotations: 78,
endAnnotations: 79,
beginAnnotation: 80,
endAnnotation: 81,
paintJpegXObject: 82,
paintImageMaskXObject: 83,
paintImageMaskXObjectGroup: 84,
paintImageXObject: 85,
paintInlineImageXObject: 86,
paintInlineImageXObjectGroup: 87,
paintImageXObjectRepeat: 88,
paintImageMaskXObjectRepeat: 89,
paintSolidColorImageMask: 90,
constructPath: 91
}
exports.OPS = OPS
const UNSUPPORTED_FEATURES = {
unknown: 'unknown',
forms: 'forms',
javaScript: 'javaScript',
signatures: 'signatures',
smask: 'smask',
shadingPattern: 'shadingPattern',
font: 'font',
errorTilingPattern: 'errorTilingPattern',
errorExtGState: 'errorExtGState',
errorXObject: 'errorXObject',
errorFontLoadType3: 'errorFontLoadType3',
errorFontState: 'errorFontState',
errorFontMissing: 'errorFontMissing',
errorFontTranslate: 'errorFontTranslate',
errorColorSpace: 'errorColorSpace',
errorOperatorList: 'errorOperatorList',
errorFontToUnicode: 'errorFontToUnicode',
errorFontLoadNative: 'errorFontLoadNative',
errorFontBuildPath: 'errorFontBuildPath',
errorFontGetPath: 'errorFontGetPath',
errorMarkedContent: 'errorMarkedContent',
errorContentSubStream: 'errorContentSubStream'
}
exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES
const PasswordResponses = {
NEED_PASSWORD: 1,
INCORRECT_PASSWORD: 2
}
exports.PasswordResponses = PasswordResponses
let verbosity = VerbosityLevel.WARNINGS
function setVerbosityLevel (level) {
if (Number.isInteger(level)) {
verbosity = level
}
}
function getVerbosityLevel () {
return verbosity
}
function info (msg) {
if (verbosity >= VerbosityLevel.INFOS) {
console.log(`Info: ${msg}`)
}
}
function warn (msg) {
if (verbosity >= VerbosityLevel.WARNINGS) {
console.log(`Warning: ${msg}`)
}
}
function unreachable (msg) {
throw new Error(msg)
}
function assert (cond, msg) {
if (!cond) {
unreachable(msg)
}
}
function isSameOrigin (baseUrl, otherUrl) {
let base
try {
base = new URL(baseUrl)
if (!base.origin || base.origin === 'null') {
return false
}
} catch (e) {
return false
}
const other = new URL(otherUrl, base)
return base.origin === other.origin
}
function _isValidProtocol (url) {
if (!url) {
return false
}
switch (url.protocol) {
case 'http:':
case 'https:':
case 'ftp:':
case 'mailto:':
case 'tel:':
return true
default:
return false
}
}
function createValidAbsoluteUrl (url, baseUrl = null, options = null) {
if (!url) {
return null
}
try {
if (options && typeof url === 'string') {
if (options.addDefaultProtocol && url.startsWith('www.')) {
const dots = url.match(/\./g)
if (dots && dots.length >= 2) {
url = `http://${url}`
}
}
if (options.tryConvertEncoding) {
try {
url = stringToUTF8String(url)
} catch (ex) {}
}
}
const absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url)
if (_isValidProtocol(absoluteUrl)) {
return absoluteUrl
}
} catch (ex) {}
return null
}
function shadow (obj, prop, value) {
Object.defineProperty(obj, prop, {
value,
enumerable: true,
configurable: true,
writable: false
})
return value
}
const BaseException = function BaseExceptionClosure () {
function BaseException (message, name) {
if (this.constructor === BaseException) {
unreachable('Cannot initialize BaseException.')
}
this.message = message
this.name = name
}
BaseException.prototype = new Error()
BaseException.constructor = BaseException
return BaseException
}()
exports.BaseException = BaseException
class PasswordException extends BaseException {
constructor (msg, code) {
super(msg, 'PasswordException')
this.code = code
}
}
exports.PasswordException = PasswordException
class UnknownErrorException extends BaseException {
constructor (msg, details) {
super(msg, 'UnknownErrorException')
this.details = details
}
}
exports.UnknownErrorException = UnknownErrorException
class InvalidPDFException extends BaseException {
constructor (msg) {
super(msg, 'InvalidPDFException')
}
}
exports.InvalidPDFException = InvalidPDFException
class MissingPDFException extends BaseException {
constructor (msg) {
super(msg, 'MissingPDFException')
}
}
exports.MissingPDFException = MissingPDFException
class UnexpectedResponseException extends BaseException {
constructor (msg, status) {
super(msg, 'UnexpectedResponseException')
this.status = status
}
}
exports.UnexpectedResponseException = UnexpectedResponseException
class FormatError extends BaseException {
constructor (msg) {
super(msg, 'FormatError')
}
}
exports.FormatError = FormatError
class AbortException extends BaseException {
constructor (msg) {
super(msg, 'AbortException')
}
}
exports.AbortException = AbortException
function bytesToString (bytes) {
if (typeof bytes !== 'object' || bytes === null || bytes.length === undefined) {
unreachable('Invalid argument for bytesToString')
}
const length = bytes.length
const MAX_ARGUMENT_COUNT = 8192
if (length < MAX_ARGUMENT_COUNT) {
return String.fromCharCode.apply(null, bytes)
}
const strBuf = []
for (let i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
const chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length)
const chunk = bytes.subarray(i, chunkEnd)
strBuf.push(String.fromCharCode.apply(null, chunk))
}
return strBuf.join('')
}
function stringToBytes (str) {
if (typeof str !== 'string') {
unreachable('Invalid argument for stringToBytes')
}
const length = str.length
const bytes = new Uint8Array(length)
for (let i = 0; i < length; ++i) {
bytes[i] = str.charCodeAt(i) & 0xff
}
return bytes
}
function arrayByteLength (arr) {
if (arr.length !== undefined) {
return arr.length
}
if (arr.byteLength !== undefined) {
return arr.byteLength
}
unreachable('Invalid argument for arrayByteLength')
}
function arraysToBytes (arr) {
const length = arr.length
if (length === 1 && arr[0] instanceof Uint8Array) {
return arr[0]
}
let resultLength = 0
for (let i = 0; i < length; i++) {
resultLength += arrayByteLength(arr[i])
}
let pos = 0
const data = new Uint8Array(resultLength)
for (let i = 0; i < length; i++) {
let item = arr[i]
if (!(item instanceof Uint8Array)) {
if (typeof item === 'string') {
item = stringToBytes(item)
} else {
item = new Uint8Array(item)
}
}
const itemLength = item.byteLength
data.set(item, pos)
pos += itemLength
}
return data
}
function string32 (value) {
return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff)
}
function objectSize (obj) {
return Object.keys(obj).length
}
function objectFromMap (map) {
const obj = Object.create(null)
for (const [key, value] of map) {
obj[key] = value
}
return obj
}
function isLittleEndian () {
const buffer8 = new Uint8Array(4)
buffer8[0] = 1
const view32 = new Uint32Array(buffer8.buffer, 0, 1)
return view32[0] === 1
}
const IsLittleEndianCached = {
get value () {
return shadow(this, 'value', isLittleEndian())
}
}
exports.IsLittleEndianCached = IsLittleEndianCached
function isEvalSupported () {
try {
new Function('')
return true
} catch (e) {
return false
}
}
const IsEvalSupportedCached = {
get value () {
return shadow(this, 'value', isEvalSupported())
}
}
exports.IsEvalSupportedCached = IsEvalSupportedCached
const hexNumbers = [...Array(256).keys()].map(n => n.toString(16).padStart(2, '0'))
class Util {
static makeHexColor (r, g, b) {
return `#${hexNumbers[r]}${hexNumbers[g]}${hexNumbers[b]}`
}
static transform (m1, m2) {
return [m1[0] * m2[0] + m1[2] * m2[1], m1[1] * m2[0] + m1[3] * m2[1], m1[0] * m2[2] + m1[2] * m2[3], m1[1] * m2[2] + m1[3] * m2[3], m1[0] * m2[4] + m1[2] * m2[5] + m1[4], m1[1] * m2[4] + m1[3] * m2[5] + m1[5]]
}
static applyTransform (p, m) {
const xt = p[0] * m[0] + p[1] * m[2] + m[4]
const yt = p[0] * m[1] + p[1] * m[3] + m[5]
return [xt, yt]
}
static applyInverseTransform (p, m) {
const d = m[0] * m[3] - m[1] * m[2]
const xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d
const yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d
return [xt, yt]
}
static getAxialAlignedBoundingBox (r, m) {
const p1 = Util.applyTransform(r, m)
const p2 = Util.applyTransform(r.slice(2, 4), m)
const p3 = Util.applyTransform([r[0], r[3]], m)
const p4 = Util.applyTransform([r[2], r[1]], m)
return [Math.min(p1[0], p2[0], p3[0], p4[0]), Math.min(p1[1], p2[1], p3[1], p4[1]), Math.max(p1[0], p2[0], p3[0], p4[0]), Math.max(p1[1], p2[1], p3[1], p4[1])]
}
static inverseTransform (m) {
const d = m[0] * m[3] - m[1] * m[2]
return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d, (m[2] * m[5] - m[4] * m[3]) / d, (m[4] * m[1] - m[5] * m[0]) / d]
}
static apply3dTransform (m, v) {
return [m[0] * v[0] + m[1] * v[1] + m[2] * v[2], m[3] * v[0] + m[4] * v[1] + m[5] * v[2], m[6] * v[0] + m[7] * v[1] + m[8] * v[2]]
}
static singularValueDecompose2dScale (m) {
const transpose = [m[0], m[2], m[1], m[3]]
const a = m[0] * transpose[0] + m[1] * transpose[2]
const b = m[0] * transpose[1] + m[1] * transpose[3]
const c = m[2] * transpose[0] + m[3] * transpose[2]
const d = m[2] * transpose[1] + m[3] * transpose[3]
const first = (a + d) / 2
const second = Math.sqrt((a + d) ** 2 - 4 * (a * d - c * b)) / 2
const sx = first + second || 1
const sy = first - second || 1
return [Math.sqrt(sx), Math.sqrt(sy)]
}
static normalizeRect (rect) {
const r = rect.slice(0)
if (rect[0] > rect[2]) {
r[0] = rect[2]
r[2] = rect[0]
}
if (rect[1] > rect[3]) {
r[1] = rect[3]
r[3] = rect[1]
}
return r
}
static intersect (rect1, rect2) {
function compare (a, b) {
return a - b
}
const orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare)
const orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare)
const result = []
rect1 = Util.normalizeRect(rect1)
rect2 = Util.normalizeRect(rect2)
if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) {
result[0] = orderedX[1]
result[2] = orderedX[2]
} else {
return null
}
if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) {
result[1] = orderedY[1]
result[3] = orderedY[2]
} else {
return null
}
return result
}
static bezierBoundingBox (x0, y0, x1, y1, x2, y2, x3, y3) {
const tvalues = [],
bounds = [[], []]
let a, b, c, t, t1, t2, b2ac, sqrtb2ac
for (let i = 0; i < 2; ++i) {
if (i === 0) {
b = 6 * x0 - 12 * x1 + 6 * x2
a = -3 * x0 + 9 * x1 - 9 * x2 + 3 * x3
c = 3 * x1 - 3 * x0
} else {
b = 6 * y0 - 12 * y1 + 6 * y2
a = -3 * y0 + 9 * y1 - 9 * y2 + 3 * y3
c = 3 * y1 - 3 * y0
}
if (Math.abs(a) < 1e-12) {
if (Math.abs(b) < 1e-12) {
continue
}
t = -c / b
if (0 < t && t < 1) {
tvalues.push(t)
}
continue
}
b2ac = b * b - 4 * c * a
sqrtb2ac = Math.sqrt(b2ac)
if (b2ac < 0) {
continue
}
t1 = (-b + sqrtb2ac) / (2 * a)
if (0 < t1 && t1 < 1) {
tvalues.push(t1)
}
t2 = (-b - sqrtb2ac) / (2 * a)
if (0 < t2 && t2 < 1) {
tvalues.push(t2)
}
}
let j = tvalues.length,
mt
const jlen = j
while (j--) {
t = tvalues[j]
mt = 1 - t
bounds[0][j] = mt * mt * mt * x0 + 3 * mt * mt * t * x1 + 3 * mt * t * t * x2 + t * t * t * x3
bounds[1][j] = mt * mt * mt * y0 + 3 * mt * mt * t * y1 + 3 * mt * t * t * y2 + t * t * t * y3
}
bounds[0][jlen] = x0
bounds[1][jlen] = y0
bounds[0][jlen + 1] = x3
bounds[1][jlen + 1] = y3
bounds[0].length = bounds[1].length = jlen + 2
return [Math.min(...bounds[0]), Math.min(...bounds[1]), Math.max(...bounds[0]), Math.max(...bounds[1])]
}
}
exports.Util = Util
const PDFStringTranslateTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2d8, 0x2c7, 0x2c6, 0x2d9, 0x2dd, 0x2db, 0x2da, 0x2dc, 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, 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, 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, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x192, 0x2044, 0x2039, 0x203a, 0x2212, 0x2030, 0x201e, 0x201c, 0x201d, 0x2018, 0x2019, 0x201a, 0x2122, 0xfb01, 0xfb02, 0x141, 0x152, 0x160, 0x178, 0x17d, 0x131, 0x142, 0x153, 0x161, 0x17e, 0, 0x20ac]
function stringToPDFString (str) {
if (str[0] >= '\xEF') {
let encoding
if (str[0] === '\xFE' && str[1] === '\xFF') {
encoding = 'utf-16be'
} else if (str[0] === '\xFF' && str[1] === '\xFE') {
encoding = 'utf-16le'
} else if (str[0] === '\xEF' && str[1] === '\xBB' && str[2] === '\xBF') {
encoding = 'utf-8'
}
if (encoding) {
try {
const decoder = new TextDecoder(encoding, {
fatal: true
})
const buffer = stringToBytes(str)
return decoder.decode(buffer)
} catch (ex) {
warn(`stringToPDFString: "${ex}".`)
}
}
}
const strBuf = []
for (let i = 0, ii = str.length; i < ii; i++) {
const code = PDFStringTranslateTable[str.charCodeAt(i)]
strBuf.push(code ? String.fromCharCode(code) : str.charAt(i))
}
return strBuf.join('')
}
function escapeString (str) {
return str.replace(/([()\\\n\r])/g, match => {
if (match === '\n') {
return '\\n'
} else if (match === '\r') {
return '\\r'
}
return `\\${match}`
})
}
function isAscii (str) {
return /^[\x00-\x7F]*$/.test(str)
}
function stringToUTF16BEString (str) {
const buf = ['\xFE\xFF']
for (let i = 0, ii = str.length; i < ii; i++) {
const char = str.charCodeAt(i)
buf.push(String.fromCharCode(char >> 8 & 0xff), String.fromCharCode(char & 0xff))
}
return buf.join('')
}
function stringToUTF8String (str) {
return decodeURIComponent(escape(str))
}
function utf8StringToString (str) {
return unescape(encodeURIComponent(str))
}
function isArrayBuffer (v) {
return typeof v === 'object' && v !== null && v.byteLength !== undefined
}
function isArrayEqual (arr1, arr2) {
if (arr1.length !== arr2.length) {
return false
}
for (let i = 0, ii = arr1.length; i < ii; i++) {
if (arr1[i] !== arr2[i]) {
return false
}
}
return true
}
function getModificationDate (date = new Date()) {
const buffer = [date.getUTCFullYear().toString(), (date.getUTCMonth() + 1).toString().padStart(2, '0'), date.getUTCDate().toString().padStart(2, '0'), date.getUTCHours().toString().padStart(2, '0'), date.getUTCMinutes().toString().padStart(2, '0'), date.getUTCSeconds().toString().padStart(2, '0')]
return buffer.join('')
}
function createPromiseCapability () {
const capability = Object.create(null)
let isSettled = false
Object.defineProperty(capability, 'settled', {
get () {
return isSettled
}
})
capability.promise = new Promise(function (resolve, reject) {
capability.resolve = function (data) {
isSettled = true
resolve(data)
}
capability.reject = function (reason) {
isSettled = true
reject(reason)
}
})
return capability
}
/***/
},
/* 2 */
/***/
(__unused_webpack_module, __unused_webpack_exports, __w_pdfjs_require__) => {
var _is_node = __w_pdfjs_require__(3)
/***/
},
/* 3 */
/***/
(__unused_webpack_module, exports) => {
Object.defineProperty(exports, '__esModule', {
value: true
})
exports.isNodeJS = void 0
const isNodeJS = typeof process === 'object' && process + '' === '[object process]' && !process.versions.nw && !(process.versions.electron && process.type && process.type !== 'browser')
exports.isNodeJS = isNodeJS
/***/
},
/* 4 */
/***/
(__unused_webpack_module, exports, __w_pdfjs_require__) => {
Object.defineProperty(exports, '__esModule', {
value: true
})
exports.build = exports.RenderTask = exports.PDFWorker = exports.PDFPageProxy = exports.PDFDocumentProxy = exports.PDFDocumentLoadingTask = exports.PDFDataRangeTransport = exports.LoopbackPort = exports.DefaultStandardFontDataFactory = exports.DefaultCanvasFactory = exports.DefaultCMapReaderFactory = void 0
exports.getDocument = getDocument
exports.setPDFNetworkStreamFactory = setPDFNetworkStreamFactory
exports.version = void 0
var _util = __w_pdfjs_require__(1)
var _display_utils = __w_pdfjs_require__(5)
var _font_loader = __w_pdfjs_require__(7)
var _node_utils = __w_pdfjs_require__(8)
var _annotation_storage = __w_pdfjs_require__(9)
var _canvas = __w_pdfjs_require__(10)
var _worker_options = __w_pdfjs_require__(12)
var _is_node = __w_pdfjs_require__(3)
var _message_handler = __w_pdfjs_require__(13)
var _metadata = __w_pdfjs_require__(14)
var _optional_content_config = __w_pdfjs_require__(15)
var _transport_stream = __w_pdfjs_require__(16)
var _xfa_text = __w_pdfjs_require__(17)
const DEFAULT_RANGE_CHUNK_SIZE = 65536
const RENDERING_CANCELLED_TIMEOUT = 100
const DefaultCanvasFactory = _is_node.isNodeJS ? _node_utils.NodeCanvasFactory : _display_utils.DOMCanvasFactory
exports.DefaultCanvasFactory = DefaultCanvasFactory
const DefaultCMapReaderFactory = _is_node.isNodeJS ? _node_utils.NodeCMapReaderFactory : _display_utils.DOMCMapReaderFactory
exports.DefaultCMapReaderFactory = DefaultCMapReaderFactory
const DefaultStandardFontDataFactory = _is_node.isNodeJS ? _node_utils.NodeStandardFontDataFactory : _display_utils.DOMStandardFontDataFactory
exports.DefaultStandardFontDataFactory = DefaultStandardFontDataFactory
let createPDFNetworkStream
function setPDFNetworkStreamFactory (pdfNetworkStreamFactory) {
createPDFNetworkStream = pdfNetworkStreamFactory
}
function getDocument (src) {
const task = new PDFDocumentLoadingTask()
let source
if (typeof src === 'string' || src instanceof URL) {
source = {
url: src
}
} else if ((0, _util.isArrayBuffer)(src)) {
source = {
data: src
}
} else if (src instanceof PDFDataRangeTransport) {
source = {
range: src
}
} else {
if (typeof src !== 'object') {
throw new Error('Invalid parameter in getDocument, ' + 'need either string, URL, Uint8Array, or parameter object.')
}
if (!src.url && !src.data && !src.range) {
throw new Error('Invalid parameter object: need either .data, .range or .url')
}
source = src
}
const params = Object.create(null)
let rangeTransport = null,
worker = null
for (const key in source) {
const value = source[key]
switch (key) {
case 'url':
if (typeof window !== 'undefined') {
try {
params[key] = new URL(value, window.location).href
continue
} catch (ex) {
(0, _util.warn)(`Cannot create valid URL: "${ex}".`)
}
} else if (typeof value === 'string' || value instanceof URL) {
params[key] = value.toString()
continue
}
throw new Error('Invalid PDF url data: ' + 'either string or URL-object is expected in the url property.')
case 'range':
rangeTransport = value
continue
case 'worker':
worker = value
continue
case 'data':
if (_is_node.isNodeJS && typeof Buffer !== 'undefined' && value instanceof Buffer) {
params[key] = new Uint8Array(value)
} else if (value instanceof Uint8Array) {
break
} else if (typeof value === 'string') {
params[key] = (0, _util.stringToBytes)(value)
} else if (typeof value === 'object' && value !== null && !isNaN(value.length)) {
params[key] = new Uint8Array(value)
} else if ((0, _util.isArrayBuffer)(value)) {
params[key] = new Uint8Array(value)
} else {
throw new Error('Invalid PDF binary data: either typed array, ' + 'string, or array-like object is expected in the data property.')
}
continue
}
params[key] = value
}
params.rangeChunkSize = params.rangeChunkSize || DEFAULT_RANGE_CHUNK_SIZE
params.CMapReaderFactory = params.CMapReaderFactory || DefaultCMapReaderFactory
params.StandardFontDataFactory = params.StandardFontDataFactory || DefaultStandardFontDataFactory
params.ignoreErrors = params.stopAtErrors !== true
params.fontExtraProperties = params.fontExtraProperties === true
params.pdfBug = params.pdfBug === true
params.enableXfa = params.enableXfa === true
if (typeof params.docBaseUrl !== 'string' || (0, _display_utils.isDataScheme)(params.docBaseUrl)) {
params.docBaseUrl = null
}
if (!Number.isInteger(params.maxImageSize)) {
params.maxImageSize = -1
}
if (typeof params.useWorkerFetch !== 'boolean') {
params.useWorkerFetch = params.CMapReaderFactory === _display_utils.DOMCMapReaderFactory && params.StandardFontDataFactory === _display_utils.DOMStandardFontDataFactory
}
if (typeof params.isEvalSupported !== 'boolean') {
params.isEvalSupported = true
}
if (typeof params.disableFontFace !== 'boolean') {
params.disableFontFace = _is_node.isNodeJS
}
if (typeof params.useSystemFonts !== 'boolean') {
params.useSystemFonts = !_is_node.isNodeJS && !params.disableFontFace
}
if (typeof params.ownerDocument === 'undefined') {
params.ownerDocument = globalThis.document
}
if (typeof params.disableRange !== 'boolean') {
params.disableRange = false
}
if (typeof params.disableStream !== 'boolean') {
params.disableStream = false
}
if (typeof params.disableAutoFetch !== 'boolean') {
params.disableAutoFetch = false
}
(0, _util.setVerbosityLevel)(params.verbosity)
if (!worker) {
const workerParams = {
verbosity: params.verbosity,
port: _worker_options.GlobalWorkerOptions.workerPort
}
worker = workerParams.port ? PDFWorker.fromPort(workerParams) : new PDFWorker(workerParams)
task._worker = worker
}
const docId = task.docId
worker.promise.then(function () {
if (task.destroyed) {
throw new Error('Loading aborted')
}
const workerIdPromise = _fetchDocument(worker, params, rangeTransport, docId)
const networkStreamPromise = new Promise(function (resolve) {
let networkStream
if (rangeTransport) {
networkStream = new _transport_stream.PDFDataTransportStream({
length: params.length,
initialData: params.initialData,
progressiveDone: params.progressiveDone,
contentDispositionFilename: params.contentDispositionFilename,
disableRange: params.disableRange,
disableStream: params.disableStream
}, rangeTransport)
} else if (!params.data) {
networkStream = createPDFNetworkStream({
url: params.url,
length: params.length,
httpHeaders: params.httpHeaders,
withCredentials: params.withCredentials,
rangeChunkSize: params.rangeChunkSize,
disableRange: params.disableRange,
disableStream: params.disableStream
})
}
resolve(networkStream)
})
return Promise.all([workerIdPromise, networkStreamPromise]).then(function ([workerId, networkStream]) {
if (task.destroyed) {
throw new Error('Loading aborted')
}
const messageHandler = new _message_handler.MessageHandler(docId, workerId, worker.port)
const transport = new WorkerTransport(messageHandler, task, networkStream, params)
task._transport = transport
messageHandler.send('Ready', null)
})
}).catch(task._capability.reject)
return task
}
async function _fetchDocument (worker, source, pdfDataRangeTransport, docId) {
if (worker.destroyed) {
throw new Error('Worker was destroyed')
}
if (pdfDataRangeTransport) {
source.length = pdfDataRangeTransport.length
source.initialData = pdfDataRangeTransport.initialData
source.progressiveDone = pdfDataRangeTransport.progressiveDone
source.contentDispositionFilename = pdfDataRangeTransport.contentDispositionFilename
}
const workerId = await worker.messageHandler.sendWithPromise('GetDocRequest', {
docId,
apiVersion: '2.13.216',
source: {
data: source.data,
url: source.url,
password: source.password,
disableAutoFetch: source.disableAutoFetch,
rangeChunkSize: source.rangeChunkSize,