前往新版Gitcode，体验更适合开发者的 AI 搜索 >>
{"version":3,"sources":["webpack://pdfjs-dist/build/pdf/webpack/universalModuleDefinition","webpack://pdfjs-dist/build/pdf/webpack/bootstrap","webpack://pdfjs-dist/build/pdf/src/pdf.js","webpack://pdfjs-dist/build/pdf/src/display/display_utils.js","webpack://pdfjs-dist/build/pdf/src/shared/util.js","webpack://pdfjs-dist/build/pdf/src/shared/compatibility.js","webpack://pdfjs-dist/build/pdf/src/shared/is_node.js","webpack://pdfjs-dist/build/pdf/src/display/api.js","webpack://pdfjs-dist/build/pdf/src/display/font_loader.js","webpack://pdfjs-dist/build/pdf/src/display/api_compatibility.js","webpack://pdfjs-dist/build/pdf/src/display/canvas.js","webpack://pdfjs-dist/build/pdf/src/display/pattern_helper.js","webpack://pdfjs-dist/build/pdf/src/display/worker_options.js","webpack://pdfjs-dist/build/pdf/src/shared/message_handler.js","webpack://pdfjs-dist/build/pdf/src/display/metadata.js","webpack://pdfjs-dist/build/pdf/src/display/xml_parser.js","webpack://pdfjs-dist/build/pdf/src/display/transport_stream.js","webpack://pdfjs-dist/build/pdf/src/display/webgl.js","webpack://pdfjs-dist/build/pdf/src/display/annotation_layer.js","webpack://pdfjs-dist/build/pdf/src/display/text_layer.js","webpack://pdfjs-dist/build/pdf/src/display/svg.js","webpack://pdfjs-dist/build/pdf/src/display/node_stream.js","webpack://pdfjs-dist/build/pdf/src/display/network_utils.js","webpack://pdfjs-dist/build/pdf/src/display/content_disposition.js","webpack://pdfjs-dist/build/pdf/src/display/network.js","webpack://pdfjs-dist/build/pdf/src/display/fetch_stream.js"],"names":["pdfjsVersion","pdfjsBuild","require","PDFNodeStream","setPDFNetworkStreamFactory","params","PDFNetworkStream","PDFFetchStream","isValidFetchUrl","DEFAULT_LINK_REL","SVG_NS","create","width","height","canvas","document","context","reset","canvasAndContext","destroy","constructor","baseUrl","isCompressed","url","compressionType","CMapCompressionType","isFetchSupported","response","cMapData","stringToBytes","reason","request","XMLHttpRequest","resolve","reject","assert","svg","createElement","offsetX","offsetY","dontFlip","centerX","viewBox","centerY","rotation","rotateA","rotateB","rotateC","rotateD","offsetCanvasX","Math","offsetCanvasY","clone","scale","convertToViewportPoint","convertToViewportRectangle","topLeft","rect","bottomRight","convertToPdfPoint","LinkTarget","NONE","SELF","BLANK","PARENT","TOP","enabled","urlNullRemoved","removeNullCharacters","link","targetStr","anchor","query","end","Object","time","name","warn","Date","timeEnd","start","toString","outBuf","longest","duration","Response","protocol","script","console","isString","pdfDateStringRegex","matches","year","parseInt","month","day","hour","minute","second","universalTimeRelation","offsetHour","offsetMinute","IDENTITY_MATRIX","FONT_IDENTITY_MATRIX","PermissionFlag","PRINT","MODIFY_CONTENTS","COPY","MODIFY_ANNOTATIONS","FILL_INTERACTIVE_FORMS","COPY_FOR_ACCESSIBILITY","ASSEMBLE","PRINT_HIGH_QUALITY","TextRenderingMode","FILL","STROKE","FILL_STROKE","INVISIBLE","FILL_ADD_TO_PATH","STROKE_ADD_TO_PATH","FILL_STROKE_ADD_TO_PATH","ADD_TO_PATH","FILL_STROKE_MASK","ADD_TO_PATH_FLAG","ImageKind","GRAYSCALE_1BPP","RGB_24BPP","RGBA_32BPP","AnnotationType","TEXT","LINK","FREETEXT","LINE","SQUARE","CIRCLE","POLYGON","POLYLINE","HIGHLIGHT","UNDERLINE","SQUIGGLY","STRIKEOUT","STAMP","CARET","INK","POPUP","FILEATTACHMENT","SOUND","MOVIE","WIDGET","SCREEN","PRINTERMARK","TRAPNET","WATERMARK","THREED","REDACT","AnnotationStateModelType","MARKED","REVIEW","AnnotationMarkedState","UNMARKED","AnnotationReviewState","ACCEPTED","REJECTED","CANCELLED","COMPLETED","AnnotationReplyType","GROUP","REPLY","AnnotationFlag","HIDDEN","NOZOOM","NOROTATE","NOVIEW","READONLY","LOCKED","TOGGLENOVIEW","LOCKEDCONTENTS","AnnotationFieldFlag","REQUIRED","NOEXPORT","MULTILINE","PASSWORD","NOTOGGLETOOFF","RADIO","PUSHBUTTON","COMBO","EDIT","SORT","FILESELECT","MULTISELECT","DONOTSPELLCHECK","DONOTSCROLL","COMB","RICHTEXT","RADIOSINUNISON","COMMITONSELCHANGE","AnnotationBorderStyleType","SOLID","DASHED","BEVELED","INSET","StreamType","UNKNOWN","FLATE","LZW","DCT","JPX","JBIG","A85","AHX","CCF","RLX","FontType","TYPE1","TYPE1C","CIDFONTTYPE0","CIDFONTTYPE0C","TRUETYPE","CIDFONTTYPE2","TYPE3","OPENTYPE","TYPE0","MMTYPE1","VerbosityLevel","ERRORS","WARNINGS","INFOS","BINARY","STREAM","OPS","dependency","setLineWidth","setLineCap","setLineJoin","setMiterLimit","setDash","setRenderingIntent","setFlatness","setGState","save","restore","transform","moveTo","lineTo","curveTo","curveTo2","curveTo3","closePath","rectangle","stroke","closeStroke","fill","eoFill","fillStroke","eoFillStroke","closeFillStroke","closeEOFillStroke","endPath","clip","eoClip","beginText","endText","setCharSpacing","setWordSpacing","setHScale","setLeading","setFont","setTextRenderingMode","setTextRise","moveText","setLeadingMoveText","setTextMatrix","nextLine","showText","showSpacedText","nextLineShowText","nextLineSetSpacingShowText","setCharWidth","setCharWidthAndBounds","setStrokeColorSpace","setFillColorSpace","setStrokeColor","setStrokeColorN","setFillColor","setFillColorN","setStrokeGray","setFillGray","setStrokeRGBColor","setFillRGBColor","setStrokeCMYKColor","setFillCMYKColor","shadingFill","beginInlineImage","beginImageData","endInlineImage","paintXObject","markPoint","markPointProps","beginMarkedContent","beginMarkedContentProps","endMarkedContent","beginCompat","endCompat","paintFormXObjectBegin","paintFormXObjectEnd","beginGroup","endGroup","beginAnnotations","endAnnotations","beginAnnotation","endAnnotation","paintJpegXObject","paintImageMaskXObject","paintImageMaskXObjectGroup","paintImageXObject","paintInlineImageXObject","paintInlineImageXObjectGroup","paintImageXObjectRepeat","paintImageMaskXObjectRepeat","paintSolidColorImageMask","constructPath","UNSUPPORTED_FEATURES","unknown","forms","javaScript","smask","shadingPattern","font","errorTilingPattern","errorExtGState","errorXObject","errorFontLoadType3","errorFontState","errorFontMissing","errorFontTranslate","errorColorSpace","errorOperatorList","errorFontToUnicode","errorFontLoadNative","errorFontGetPath","PasswordResponses","NEED_PASSWORD","INCORRECT_PASSWORD","verbosity","Number","unreachable","base","other","absoluteUrl","_isValidProtocol","enumerable","configurable","writable","BaseException","NullCharactersRegExp","str","bytes","length","MAX_ARGUMENT_COUNT","String","strBuf","i","chunkEnd","chunk","arr","resultLength","arrayByteLength","pos","data","item","itemLength","value","buffer8","view32","IsLittleEndianCached","shadow","isLittleEndian","IsEvalSupportedCached","isEvalSupported","rgbBuf","m1","m2","xt","p","m","yt","d","p1","Util","p2","r","p3","p4","v","transpose","a","b","c","first","sx","sy","orderedX","rect1","rect2","orderedY","result","PDFStringTranslateTable","code","decodeURIComponent","escape","unescape","encodeURIComponent","arr1","arr2","element","capability","isSettled","get","createObjectURL","digits","forceDataSchema","URL","blob","type","buffer","ii","b1","b2","b3","d1","d2","d3","d4","isNodeJS","process","DEFAULT_RANGE_CHUNK_SIZE","RENDERING_CANCELLED_TIMEOUT","createPDFNetworkStream","task","source","isArrayBuffer","src","range","rangeTransport","worker","key","window","pdfBytes","isNaN","apiCompatibilityParams","setVerbosityLevel","workerParams","port","GlobalWorkerOptions","PDFWorker","docId","workerIdPromise","_fetchDocument","networkStreamPromise","networkStream","initialData","progressiveDone","disableRange","disableStream","httpHeaders","withCredentials","rangeChunkSize","messageHandler","transport","Promise","pdfDataRangeTransport","apiVersion","password","disableAutoFetch","maxImageSize","disableFontFace","postMessageTransfers","docBaseUrl","ignoreErrors","fontExtraProperties","PDFDocumentLoadingTask","nextDocumentId","transportDestroyed","addRangeListener","addProgressListener","addProgressiveReadListener","addProgressiveDoneListener","onDataRange","listener","onDataProgress","onDataProgressiveRead","onDataProgressiveDone","transportReady","requestDataRange","abort","getPage","getPageIndex","getDestinations","getDestination","getPageLabels","getPageLayout","getPageMode","getViewerPreferences","getOpenAction","getOpenActionDestination","deprecated","openAction","getAttachments","getJavaScript","getOutline","getPermissions","getMetadata","getData","getDownloadInfo","getStats","cleanup","pdfBug","getViewport","getAnnotations","intent","render","enableWebGL","renderInteractiveForms","imageLayer","canvasFactory","background","renderingIntent","intentState","clearTimeout","canvasFactoryInstance","webGLContext","enable","fnArray","argsArray","lastChunk","pageIndex","complete","error","internalRenderTask","callback","objs","commonObjs","operatorList","useRequestAnimationFrame","renderTask","transparency","getOperatorList","opListTask","streamTextContent","normalizeWhitespace","disableCombineTextItems","TEXT_CONTENT_CHUNK_SIZE","combineTextItems","highWaterMark","size","textContent","getTextContent","readableStream","reader","pump","items","styles","_destroy","waitOn","force","renderCompleted","resetStats","_tryCleanup","_startRenderPage","_renderPageChunk","operatorListChunk","_pumpOperatorList","args","_abortOperatorList","defer","postMessage","cloned","transferable","transfers","Array","desc","cloneValue","e","addEventListener","removeEventListener","terminate","pdfWorkerPorts","isWorkerDisabled","nextFakeWorkerId","fallbackWorkerSrc","pdfjsFilePath","mainWorkerMessageHandler","globalThis","fakeWorkerCapability","loader","getMainThreadWorkerMessageHandler","eval","getWorkerSrc","loadScript","wrapper","_initializeFromPort","_initialize","workerSrc","isSameOrigin","createCDNWrapper","terminateEarly","onWorkerError","sendTest","testObj","info","_setupFakeWorker","setupFakeWorkerGlobal","WorkerMessageHandler","id","workerHandler","loadingTask","onUnsupportedFeature","page","terminated","setupMessageHandler","evt","loaded","total","sink","headersCapability","fullReader","isStreamingSupported","isRangeSupported","contentLength","rangeReader","pdfInfo","ex","exception","updatePassword","exportedError","exportedData","fontRegistry","registerFont","pageProxy","MAX_IMAGE_SIZE_TO_STORE","imageData","fetched","builtInCMap","_onUnsupportedFeature","pageNumber","promise","pageInfo","results","metadata","contentDispositionFilename","startCleanup","cleanupSuccessful","_ensureObj","resolved","obj","has","clear","cancel","InternalRenderTask","canvasInRendering","initializeGraphics","operatorListChanged","_continue","_scheduleNext","version","build","addNativeFontFace","insertRule","styleElement","styleSheet","nativeFontFace","featureId","rule","_queueLoadingCallback","supported","_prepareFontLoadEvent","FontLoader","requests","nextRequestId","navigator","otherRequest","setTimeout","done","getLoadTestFont","atob","offset","chunk1","s","chunk2","ctx","called","isFontReady","loadTestFontId","COMMENT_OFFSET","spliceString","CFF_CHECKSUM_OFFSET","XXXX_VALUE","checksum","int32","string32","btoa","names","fonts","div","span","translatedData","createNativeFontFace","createFontFaceRule","bytesToString","getPathGenerator","cmds","js","current","compatibilityParams","MIN_FONT_SIZE","MAX_FONT_SIZE","MAX_GROUP_SIZE","MIN_WIDTH_FACTOR","COMPILE_TYPE3_GLYPHS","MAX_SIZE_TO_COMPILE","FULL_CHUNK_HEIGHT","f","ad_bc","bc_ad","old","prev","cosValue","sinValue","CachedCanvases","getCanvas","canvasEntry","addContextCurrentTransform","POINT_TO_PROCESS_LIMIT","imgData","width1","points","POINT_TYPES","lineSize","data0","mask","elem","count","j","j0","sum","steps","outlines","coords","p0","step","pp","drawOutline","k","kk","o","l","ll","CanvasExtraState","setCurrentPoint","CanvasGraphics","EXECUTION_TIME","EXECUTION_STEPS","partialChunkHeight","fullChunks","totalChunks","chunkImgData","srcPos","dest","srcLength","dest32","dest32DataLength","fullSrcDiff","white","black","thisChunkHeight","destPos","srcDiff","kEnd","kEndUnrolled","srcByte","elemsInThisChunk","properties","property","sourceCtx","destCtx","alpha","alpha_","r0","g0","b0","maskData","transferMap","layerData","y","hasBackdrop","backdrop","subtype","composeFn","PIXELS_TO_PROCESS","chunkSize","row","chunkHeight","maskCtx","layerCtx","composeSMaskBackdrop","composed","layer","genericComposeSMask","LINE_CAP_STYLES","LINE_JOIN_STYLES","NORMAL_CLIP","EO_CLIP","beginDrawing","transparentCanvas","resetCtxToDefault","viewport","executeOperatorList","executionStartIdx","argsArrayLen","chunkOperations","endTime","stepper","fnId","objsPool","depObjId","continueCallback","endDrawing","states","state","beginSMaskGroup","activeSMask","drawnWidth","drawnHeight","cacheId","scratchCanvas","currentCtx","currentTransform","groupCtx","copyCtxState","suspendSMaskGroup","composeSMask","deltaTransform","resumeSMaskGroup","endSMaskGroup","x","ops","xw","yh","consumePath","strokeColor","fillColor","isPatternFill","needRestore","paths","path","fontObj","bold","italic","typeface","browserFontSize","paintChar","textRenderingMode","fontSize","fillStrokeMode","isAddToPathSet","patternFill","addToPath","fontSizeScale","charSpacing","wordSpacing","fontDirection","textHScale","glyphsLength","glyphs","vertical","spacingDir","defaultVMetrics","widthAdvanceScale","simpleFillText","pattern","patternTransform","lineWidth","glyph","isNum","restoreNeeded","spacing","character","accent","vmetric","vx","vy","scaledX","scaledY","measuredWidth","characterScaleX","scaledAccentX","scaledAccentY","charWidth","showType3Text","fontMatrix","isTextInvisible","spacingLength","transformed","urx","ury","getColorN_Pattern","IR","color","baseTransform","canvasGraphicsFactory","createCanvasGraphics","getShadingPatternFromIR","inv","bl","br","ul","ur","x0","y0","x1","y1","matrix","bbox","group","bounds","canvasBounds","scaleX","scaleY","startTransformInverse","img","maskCanvas","putBinaryImageMask","positions","images","image","objId","map","w","h","widthScale","heightScale","imgToPaint","tmpCanvas","tmpCtx","putBinaryImageData","paintWidth","paintHeight","tmpCanvasId","newWidth","newHeight","position","left","top","entry","getSinglePixelWidth","inverse","getCanvasPosition","ShadingIRs","region","fromIR","raw","colorStops","r1","getPattern","applyBoundingBox","grad","createMeshCanvas","colors","rowSize","tmp","c1","c2","c3","x2","y2","x3","y3","c1r","c1g","c1b","c2r","c2g","c2b","c3r","c3g","c3b","minY","maxY","xa","car","cag","cab","xb","cbr","cbg","cbb","x1_","x2_","ps","figure","cs","verticesPerRow","rows","cols","q","drawTriangle","EXPECTED_SCALE","MAX_PATTERN_SIZE","BORDER_SIZE","boundsWidth","boundsHeight","combinesScale","paddedWidth","paddedHeight","cachedCanvases","backgroundColor","figures","drawFigure","owner","matrixScale","temporaryPatternCanvas","shadingIR","TilingPattern","PaintType","COLORED","UNCOLORED","createPatternCanvas","xstep","ystep","paintType","tilingType","curMatrixScale","combinedScale","dimx","dimy","graphics","getSizeAndScale","maxSize","clipBbox","bboxWidth","bboxHeight","setFillAndStrokeStyleToContext","cssColor","CallbackKind","DATA","ERROR","StreamKind","CANCEL","CANCEL_COMPLETE","CLOSE","ENQUEUE","PULL","PULL_COMPLETE","START_COMPLETE","event","callbackId","wrapReason","action","cbSourceName","cbTargetName","comObj","sourceName","targetName","on","ah","send","sendWithPromise","sendWithStream","streamId","controller","startCapability","startCall","pullCall","cancelCall","isClosed","desiredSize","pull","pullCapability","stream","cancelCapability","_createStreamSink","self","streamSink","enqueue","lastDesiredSize","close","sinkCapability","onPull","onCancel","isCancelled","ready","success","_processStreamMessage","_postMessage","parser","xmlDocument","_repair","chars","_parse","rdf","nodeName","children","jj","getAll","XMLParserErrorCode","NoError","EndOfDocument","UnterminatedCdat","UnterminatedXmlDeclaration","UnterminatedDoctypeDeclaration","UnterminatedComment","MalformedElement","OutOfMemory","UnterminatedAttributeValue","UnterminatedElement","ElementNeverBegun","ch","isWhitespace","_resolveEntities","entity","_parseContent","attributes","skipWs","attrName","attrValue","attrEndChar","attrEndIndex","parsed","_parseProcessingInstruction","attrStart","parseXml","ch2","pi","q2","complexDoctype","doctypeContent","content","text","onResolveEntity","onPi","onComment","onCdata","onDoctype","onText","onBeginElement","onEndElement","onError","childNodes","index","child","hasChildNodes","parseFromString","isWhitespaceString","node","lastElement","_onReceiveData","found","_onProgress","firstReader","_onProgressiveDone","_removeRangeReader","getFullReader","queuedChunks","getRangeReader","cancelAllRequests","readers","_enqueue","requestCapability","requestsCapability","WebGLUtils","drawFigures","shader","gl","compiled","errorMsg","loadShader","program","shaders","linked","texture","currentCanvas","currentGL","premultipliedalpha","smaskVertexShaderCode","smaskFragmentShaderCode","smaskCache","generateGL","vertexShader","createVertexShader","fragmentShader","createFragmentShader","cache","texCoordLocation","texLayerLocation","texMaskLocation","texCoordBuffer","initSmaskGL","createTexture","maskTexture","figuresVertexShaderCode","figuresFragmentShaderCode","figuresCache","initFiguresGL","coordsMap","colorsMap","pIndex","cIndex","col","coordsBuffer","colorsBuffer","tryInitGL","parameters","fieldType","isRenderable","ignoreBorder","_createContainer","container","horizontalRadius","verticalRadius","radius","_createPopup","trigger","popupElement","title","modificationDate","contents","hideWrapper","popup","addLinkAttributes","target","linkService","rel","_bindLink","_bindNamedAction","JSON","TEXT_ALIGNMENT","fieldWidth","combWidth","_setTextStyle","style","fontFamily","fallbackName","selectElement","optionElement","option","IGNORE_TYPES","selector","parentElement","parentLeft","parseFloat","parentWidth","BACKGROUND_ENLIGHT","g","dateObject","PDFDateString","date","_formatContents","lines","line","_toggle","_show","pin","_hide","unpin","borderWidth","square","circle","coordinate","polyline","getFilenameFromUrl","stringToPDFString","_download","sortedAnnotations","popupAnnotations","downloadManager","imageResourcesPath","svgFactory","renderTextLayer","MAX_TEXT_DIVS_TO_RENDER","NonWhitespaceRegexp","textDiv","textDivProperties","angle","canvasWidth","originalTransform","paddingBottom","paddingLeft","paddingRight","paddingTop","isAllWhitespace","geom","tx","fontHeight","fontAscent","shouldScaleText","absScaleX","absScaleY","angleCos","angleSin","divWidth","divHeight","right","bottom","textDivs","textDivsLength","t","ts","expanded","expandBounds","divProperties","boxScale","findPositiveMin","box","x1New","x2New","expandBoundsLTR","boxes","fakeBoundary","horizon","boundary","maxXNew","horizonPart","affectedBoundary","xNew","changedHorizon","lastBoundary","useBoundary","used","textContentItemsStr","TextLayerRenderTask","_processItems","len","appendText","_layoutText","_render","styleCache","textItems","textStyles","expandTextDivs","expand","transformBuf","paddingBuf","divProps","renderParameters","textContentStream","enhanceTextSelection","SVGGraphics","SVG_DEFAULTS","fontStyle","fontWeight","XML_NS","XLINK_NS","convertImgDataToPng","PNG_HEADER","CHUNK_WRAPPER_SIZE","crcTable","crc","body","crc32","deflateSyncUncompressed","input","Buffer","output","__non_webpack_require__","level","literals","maxBlockLength","deflateBlocks","idat","adler","adler32","colorType","bitDepth","offsetLiterals","offsetBytes","kind","ihdr","deflateSync","pngLength","writePngChunk","encode","opTree","opListElement","fn","pf","clipCount","maskCount","shadingCount","loadDependencies","transformMatrix","getSVG","svgElement","convertOpList","operatorIdMapping","opList","opListToTree","executeOpTree","opTreeElement","lineWidthScale","textMatrix","pm","addFontStyle","details","setStrokeAlpha","setFillAlpha","_makeColorN_Pattern","_makeTilingPattern","tilingId","txstep","tystep","tiling","tx1","ty1","_makeShadingPattern","shadingId","point0","point1","gradient","focalPoint","circlePoint","focalRadius","circleRadius","stop","colorStop","op","clipId","clipPath","clipElement","_setStrokeAttributes","dashArray","imgSrc","cliprect","imgEl","definitions","rootGroup","_ensureClipGroup","clipGroup","_ensureTransformGroup","fs","http","https","fileUriRegex","parsedUrl","parseUrl","_error","_setReadableStream","auth","host","method","handleResponse","getResponseHeader","isHttp","suggestedLength","extractFilenameFromHeader","createRequestOptions","stat","returnValues","allowRangeRequests","contentEncoding","contentDisposition","filename","getFilenameFromContentDispositionHeader","status","needsEncodingFixup","toParamRegExp","rfc2616unquote","rfc5987decode","rfc2047decode","fixupEncoding","rfc2231getparam","decoder","fatal","textdecode","iter","n","parts","part","quotindex","encodingend","extvalue","encoding","langvalue","OK_RESPONSE","PARTIAL_CONTENT_RESPONSE","xhr","array","requestRange","listeners","requestFull","xhrId","pendingRequest","onProgress","onStateChange","xhrStatus","ok_response_on_range_request","getArrayBuffer","rangeHeader","begin","hasPendingRequests","getRequestXhr","isPendingRequest","abortAllRequests","abortRequest","_onRangeRequestReaderClosed","onHeadersReceived","onDone","manager","_onHeadersReceived","fullRequestXhrId","fullRequestXhr","_onDone","_onError","createResponseStatusError","_close","signal","abortController","mode","credentials","redirect","headers","createHeaders","fetch","createFetchOptions","validateResponseStatus"],"mappings":"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","file":"pdf.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine(\"pdfjs-dist/build/pdf\", [], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"pdfjs-dist/build/pdf\"] = factory();\n\telse\n\t\troot[\"pdfjs-dist/build/pdf\"] = factory();\n})(this, function() {\nreturn "," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __w_pdfjs_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __w_pdfjs_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__w_pdfjs_require__.m = modules;\n\n \t// expose the module cache\n \t__w_pdfjs_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__w_pdfjs_require__.d = function(exports, name, getter) {\n \t\tif(!__w_pdfjs_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__w_pdfjs_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__w_pdfjs_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __w_pdfjs_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__w_pdfjs_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __w_pdfjs_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__w_pdfjs_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__w_pdfjs_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__w_pdfjs_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__w_pdfjs_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __w_pdfjs_require__(__w_pdfjs_require__.s = 0);\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n addLinkAttributes,\n getFilenameFromUrl,\n isFetchSupported,\n isValidFetchUrl,\n LinkTarget,\n loadScript,\n PDFDateString,\n RenderingCancelledException,\n} from \"./display/display_utils.js\";\nimport {\n build,\n getDocument,\n LoopbackPort,\n PDFDataRangeTransport,\n PDFWorker,\n setPDFNetworkStreamFactory,\n version,\n} from \"./display/api.js\";\nimport {\n CMapCompressionType,\n createObjectURL,\n createPromiseCapability,\n createValidAbsoluteUrl,\n InvalidPDFException,\n MissingPDFException,\n OPS,\n PasswordResponses,\n PermissionFlag,\n removeNullCharacters,\n shadow,\n UnexpectedResponseException,\n UNSUPPORTED_FEATURES,\n Util,\n VerbosityLevel,\n} from \"./shared/util.js\";\nimport { AnnotationLayer } from \"./display/annotation_layer.js\";\nimport { apiCompatibilityParams } from \"./display/api_compatibility.js\";\nimport { GlobalWorkerOptions } from \"./display/worker_options.js\";\nimport { renderTextLayer } from \"./display/text_layer.js\";\nimport { SVGGraphics } from \"./display/svg.js\";\n\n/* eslint-disable-next-line no-unused-vars */\nconst pdfjsVersion =\n typeof PDFJSDev !== \"undefined\" ? PDFJSDev.eval(\"BUNDLE_VERSION\") : void 0;\n/* eslint-disable-next-line no-unused-vars */\nconst pdfjsBuild =\n typeof PDFJSDev !== \"undefined\" ? PDFJSDev.eval(\"BUNDLE_BUILD\") : void 0;\n\nif (typeof PDFJSDev === \"undefined\" || !PDFJSDev.test(\"PRODUCTION\")) {\n const streamsPromise = Promise.all([\n import(\"pdfjs/display/network.js\"),\n import(\"pdfjs/display/fetch_stream.js\"),\n ]);\n setPDFNetworkStreamFactory(params => {\n return streamsPromise.then(streams => {\n const [{ PDFNetworkStream }, { PDFFetchStream }] = streams;\n if (isFetchSupported() && isValidFetchUrl(params.url)) {\n return new PDFFetchStream(params);\n }\n return new PDFNetworkStream(params);\n });\n });\n} else if (PDFJSDev.test(\"GENERIC\")) {\n const { isNodeJS } = require(\"./shared/is_node.js\");\n if (isNodeJS) {\n const PDFNodeStream = require(\"./display/node_stream.js\").PDFNodeStream;\n setPDFNetworkStreamFactory(params => {\n return new PDFNodeStream(params);\n });\n } else {\n const PDFNetworkStream = require(\"./display/network.js\").PDFNetworkStream;\n let PDFFetchStream;\n if (isFetchSupported()) {\n PDFFetchStream = require(\"./display/fetch_stream.js\").PDFFetchStream;\n }\n setPDFNetworkStreamFactory(params => {\n if (PDFFetchStream && isValidFetchUrl(params.url)) {\n return new PDFFetchStream(params);\n }\n return new PDFNetworkStream(params);\n });\n }\n} else if (PDFJSDev.test(\"CHROME\")) {\n const PDFNetworkStream = require(\"./display/network.js\").PDFNetworkStream;\n let PDFFetchStream;\n const isChromeWithFetchCredentials = function () {\n // fetch does not include credentials until Chrome 61.0.3138.0 and later.\n // https://chromium.googlesource.com/chromium/src/+/2e231cf052ca5e68e22baf0008ac9e5e29121707\n try {\n // Indexed properties on window are read-only in Chrome 61.0.3151.0+\n // https://chromium.googlesource.com/chromium/src.git/+/58ab4a971b06dec13e4edf9de8382ca6847f6190\n window[999] = 123; // should throw. Note: JS strict mode MUST be enabled.\n delete window[999];\n return false;\n } catch (e) {\n return true;\n }\n };\n if (isFetchSupported() && isChromeWithFetchCredentials()) {\n PDFFetchStream = require(\"./display/fetch_stream.js\").PDFFetchStream;\n }\n setPDFNetworkStreamFactory(params => {\n if (PDFFetchStream && isValidFetchUrl(params.url)) {\n return new PDFFetchStream(params);\n }\n return new PDFNetworkStream(params);\n });\n}\n\nexport {\n // From \"./display/display_utils.js\":\n addLinkAttributes,\n getFilenameFromUrl,\n LinkTarget,\n loadScript,\n PDFDateString,\n RenderingCancelledException,\n // From \"./display/api.js\":\n build,\n getDocument,\n LoopbackPort,\n PDFDataRangeTransport,\n PDFWorker,\n version,\n // From \"./shared/util.js\":\n CMapCompressionType,\n createObjectURL,\n createPromiseCapability,\n createValidAbsoluteUrl,\n InvalidPDFException,\n MissingPDFException,\n OPS,\n PasswordResponses,\n PermissionFlag,\n removeNullCharacters,\n shadow,\n UnexpectedResponseException,\n UNSUPPORTED_FEATURES,\n Util,\n VerbosityLevel,\n // From \"./display/annotation_layer.js\":\n AnnotationLayer,\n // From \"./display/api_compatibility.js\":\n apiCompatibilityParams,\n // From \"./display/worker_options.js\":\n GlobalWorkerOptions,\n // From \"./display/text_layer.js\":\n renderTextLayer,\n // From \"./display/svg.js\":\n SVGGraphics,\n};\n","/* Copyright 2015 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error */\n\nimport {\n assert,\n BaseException,\n CMapCompressionType,\n isString,\n removeNullCharacters,\n stringToBytes,\n Util,\n warn,\n} from \"../shared/util.js\";\n\nconst DEFAULT_LINK_REL = \"noopener noreferrer nofollow\";\nconst SVG_NS = \"http://www.w3.org/2000/svg\";\n\nclass DOMCanvasFactory {\n create(width, height) {\n if (width <= 0 || height <= 0) {\n throw new Error(\"Invalid canvas size\");\n }\n const canvas = document.createElement(\"canvas\");\n const context = canvas.getContext(\"2d\");\n canvas.width = width;\n canvas.height = height;\n return {\n canvas,\n context,\n };\n }\n\n reset(canvasAndContext, width, height) {\n if (!canvasAndContext.canvas) {\n throw new Error(\"Canvas is not specified\");\n }\n if (width <= 0 || height <= 0) {\n throw new Error(\"Invalid canvas size\");\n }\n canvasAndContext.canvas.width = width;\n canvasAndContext.canvas.height = height;\n }\n\n destroy(canvasAndContext) {\n if (!canvasAndContext.canvas) {\n throw new Error(\"Canvas is not specified\");\n }\n // Zeroing the width and height cause Firefox to release graphics\n // resources immediately, which can greatly reduce memory consumption.\n canvasAndContext.canvas.width = 0;\n canvasAndContext.canvas.height = 0;\n canvasAndContext.canvas = null;\n canvasAndContext.context = null;\n }\n}\n\nclass DOMCMapReaderFactory {\n constructor({ baseUrl = null, isCompressed = false }) {\n this.baseUrl = baseUrl;\n this.isCompressed = isCompressed;\n }\n\n async fetch({ name }) {\n if (!this.baseUrl) {\n throw new Error(\n 'The CMap \"baseUrl\" parameter must be specified, ensure that ' +\n 'the \"cMapUrl\" and \"cMapPacked\" API parameters are provided.'\n );\n }\n if (!name) {\n throw new Error(\"CMap name must be specified.\");\n }\n const url = this.baseUrl + name + (this.isCompressed ? \".bcmap\" : \"\");\n const compressionType = this.isCompressed\n ? CMapCompressionType.BINARY\n : CMapCompressionType.NONE;\n\n if (\n (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"MOZCENTRAL\")) ||\n (isFetchSupported() && isValidFetchUrl(url, document.baseURI))\n ) {\n return fetch(url)\n .then(async response => {\n if (!response.ok) {\n throw new Error(response.statusText);\n }\n let cMapData;\n if (this.isCompressed) {\n cMapData = new Uint8Array(await response.arrayBuffer());\n } else {\n cMapData = stringToBytes(await response.text());\n }\n return { cMapData, compressionType };\n })\n .catch(reason => {\n throw new Error(\n `Unable to load ${this.isCompressed ? \"binary \" : \"\"}` +\n `CMap at: ${url}`\n );\n });\n }\n\n // The Fetch API is not supported.\n return new Promise((resolve, reject) => {\n const request = new XMLHttpRequest();\n request.open(\"GET\", url, true);\n\n if (this.isCompressed) {\n request.responseType = \"arraybuffer\";\n }\n request.onreadystatechange = () => {\n if (request.readyState !== XMLHttpRequest.DONE) {\n return;\n }\n if (request.status === 200 || request.status === 0) {\n let cMapData;\n if (this.isCompressed && request.response) {\n cMapData = new Uint8Array(request.response);\n } else if (!this.isCompressed && request.responseText) {\n cMapData = stringToBytes(request.responseText);\n }\n if (cMapData) {\n resolve({ cMapData, compressionType });\n return;\n }\n }\n reject(new Error(request.statusText));\n };\n\n request.send(null);\n }).catch(reason => {\n throw new Error(\n `Unable to load ${this.isCompressed ? \"binary \" : \"\"}` +\n `CMap at: ${url}`\n );\n });\n }\n}\n\nclass DOMSVGFactory {\n create(width, height) {\n assert(width > 0 && height > 0, \"Invalid SVG dimensions\");\n\n const svg = document.createElementNS(SVG_NS, \"svg:svg\");\n svg.setAttribute(\"version\", \"1.1\");\n svg.setAttribute(\"width\", width + \"px\");\n svg.setAttribute(\"height\", height + \"px\");\n svg.setAttribute(\"preserveAspectRatio\", \"none\");\n svg.setAttribute(\"viewBox\", \"0 0 \" + width + \" \" + height);\n\n return svg;\n }\n\n createElement(type) {\n assert(typeof type === \"string\", \"Invalid SVG element type\");\n\n return document.createElementNS(SVG_NS, type);\n }\n}\n\n/**\n * @typedef {Object} PageViewportParameters\n * @property {Array} viewBox - The xMin, yMin, xMax and yMax coordinates.\n * @property {number} scale - The scale of the viewport.\n * @property {number} rotation - The rotation, in degrees, of the viewport.\n * @property {number} [offsetX] - The horizontal, i.e. x-axis, offset. The\n * default value is `0`.\n * @property {number} [offsetY] - The vertical, i.e. y-axis, offset. The\n * default value is `0`.\n * @property {boolean} [dontFlip] - If true, the y-axis will not be flipped.\n * The default value is `false`.\n */\n\n/**\n * @typedef {Object} PageViewportCloneParameters\n * @property {number} [scale] - The scale, overriding the one in the cloned\n * viewport. The default value is `this.scale`.\n * @property {number} [rotation] - The rotation, in degrees, overriding the one\n * in the cloned viewport. The default value is `this.rotation`.\n * @property {number} [offsetX] - The horizontal, i.e. x-axis, offset.\n * The default value is `this.offsetX`.\n * @property {number} [offsetY] - The vertical, i.e. y-axis, offset.\n * The default value is `this.offsetY`.\n * @property {boolean} [dontFlip] - If true, the x-axis will not be flipped.\n * The default value is `false`.\n */\n\n/**\n * PDF page viewport created based on scale, rotation and offset.\n */\nclass PageViewport {\n /**\n * @param {PageViewportParameters}\n */\n constructor({\n viewBox,\n scale,\n rotation,\n offsetX = 0,\n offsetY = 0,\n dontFlip = false,\n }) {\n this.viewBox = viewBox;\n this.scale = scale;\n this.rotation = rotation;\n this.offsetX = offsetX;\n this.offsetY = offsetY;\n\n // creating transform to convert pdf coordinate system to the normal\n // canvas like coordinates taking in account scale and rotation\n const centerX = (viewBox[2] + viewBox[0]) / 2;\n const centerY = (viewBox[3] + viewBox[1]) / 2;\n let rotateA, rotateB, rotateC, rotateD;\n rotation = rotation % 360;\n rotation = rotation < 0 ? rotation + 360 : rotation;\n switch (rotation) {\n case 180:\n rotateA = -1;\n rotateB = 0;\n rotateC = 0;\n rotateD = 1;\n break;\n case 90:\n rotateA = 0;\n rotateB = 1;\n rotateC = 1;\n rotateD = 0;\n break;\n case 270:\n rotateA = 0;\n rotateB = -1;\n rotateC = -1;\n rotateD = 0;\n break;\n case 0:\n rotateA = 1;\n rotateB = 0;\n rotateC = 0;\n rotateD = -1;\n break;\n default:\n throw new Error(\n \"PageViewport: Invalid rotation, must be a multiple of 90 degrees.\"\n );\n }\n\n if (dontFlip) {\n rotateC = -rotateC;\n rotateD = -rotateD;\n }\n\n let offsetCanvasX, offsetCanvasY;\n let width, height;\n if (rotateA === 0) {\n offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;\n offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;\n width = Math.abs(viewBox[3] - viewBox[1]) * scale;\n height = Math.abs(viewBox[2] - viewBox[0]) * scale;\n } else {\n offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;\n offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;\n width = Math.abs(viewBox[2] - viewBox[0]) * scale;\n height = Math.abs(viewBox[3] - viewBox[1]) * scale;\n }\n // creating transform for the following operations:\n // translate(-centerX, -centerY), rotate and flip vertically,\n // scale, and translate(offsetCanvasX, offsetCanvasY)\n this.transform = [\n rotateA * scale,\n rotateB * scale,\n rotateC * scale,\n rotateD * scale,\n offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY,\n offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY,\n ];\n\n this.width = width;\n this.height = height;\n }\n\n /**\n * Clones viewport, with optional additional properties.\n * @param {PageViewportCloneParameters} [params]\n * @returns {PageViewport} Cloned viewport.\n */\n clone({\n scale = this.scale,\n rotation = this.rotation,\n offsetX = this.offsetX,\n offsetY = this.offsetY,\n dontFlip = false,\n } = {}) {\n return new PageViewport({\n viewBox: this.viewBox.slice(),\n scale,\n rotation,\n offsetX,\n offsetY,\n dontFlip,\n });\n }\n\n /**\n * Converts PDF point to the viewport coordinates. For examples, useful for\n * converting PDF location into canvas pixel coordinates.\n * @param {number} x - The x-coordinate.\n * @param {number} y - The y-coordinate.\n * @returns {Object} Object containing `x` and `y` properties of the\n * point in the viewport coordinate space.\n * @see {@link convertToPdfPoint}\n * @see {@link convertToViewportRectangle}\n */\n convertToViewportPoint(x, y) {\n return Util.applyTransform([x, y], this.transform);\n }\n\n /**\n * Converts PDF rectangle to the viewport coordinates.\n * @param {Array} rect - The xMin, yMin, xMax and yMax coordinates.\n * @returns {Array} Array containing corresponding coordinates of the\n * rectangle in the viewport coordinate space.\n * @see {@link convertToViewportPoint}\n */\n convertToViewportRectangle(rect) {\n const topLeft = Util.applyTransform([rect[0], rect[1]], this.transform);\n const bottomRight = Util.applyTransform([rect[2], rect[3]], this.transform);\n return [topLeft[0], topLeft[1], bottomRight[0], bottomRight[1]];\n }\n\n /**\n * Converts viewport coordinates to the PDF location. For examples, useful\n * for converting canvas pixel location into PDF one.\n * @param {number} x - The x-coordinate.\n * @param {number} y - The y-coordinate.\n * @returns {Object} Object containing `x` and `y` properties of the\n * point in the PDF coordinate space.\n * @see {@link convertToViewportPoint}\n */\n convertToPdfPoint(x, y) {\n return Util.applyInverseTransform([x, y], this.transform);\n }\n}\n\nclass RenderingCancelledException extends BaseException {\n constructor(msg, type) {\n super(msg);\n this.type = type;\n }\n}\n\nconst LinkTarget = {\n NONE: 0, // Default value.\n SELF: 1,\n BLANK: 2,\n PARENT: 3,\n TOP: 4,\n};\n\n/**\n * @typedef ExternalLinkParameters\n * @typedef {Object} ExternalLinkParameters\n * @property {string} url - An absolute URL.\n * @property {LinkTarget} [target] - The link target. The default value is\n * `LinkTarget.NONE`.\n * @property {string} [rel] - The link relationship. The default value is\n * `DEFAULT_LINK_REL`.\n * @property {boolean} [enabled] - Whether the link should be enabled. The\n * default value is true.\n */\n\n/**\n * Adds various attributes (href, title, target, rel) to hyperlinks.\n * @param {HTMLLinkElement} link - The link element.\n * @param {ExternalLinkParameters} params\n */\nfunction addLinkAttributes(link, { url, target, rel, enabled = true } = {}) {\n assert(\n url && typeof url === \"string\",\n 'addLinkAttributes: A valid \"url\" parameter must provided.'\n );\n\n const urlNullRemoved = removeNullCharacters(url);\n if (enabled) {\n link.href = link.title = urlNullRemoved;\n } else {\n link.href = \"\";\n link.title = `Disabled: ${urlNullRemoved}`;\n link.onclick = () => {\n return false;\n };\n }\n\n let targetStr = \"\"; // LinkTarget.NONE\n switch (target) {\n case LinkTarget.NONE:\n break;\n case LinkTarget.SELF:\n targetStr = \"_self\";\n break;\n case LinkTarget.BLANK:\n targetStr = \"_blank\";\n break;\n case LinkTarget.PARENT:\n targetStr = \"_parent\";\n break;\n case LinkTarget.TOP:\n targetStr = \"_top\";\n break;\n }\n link.target = targetStr;\n\n link.rel = typeof rel === \"string\" ? rel : DEFAULT_LINK_REL;\n}\n\n// Gets the file name from a given URL.\nfunction getFilenameFromUrl(url) {\n const anchor = url.indexOf(\"#\");\n const query = url.indexOf(\"?\");\n const end = Math.min(\n anchor > 0 ? anchor : url.length,\n query > 0 ? query : url.length\n );\n return url.substring(url.lastIndexOf(\"/\", end) + 1, end);\n}\n\nclass StatTimer {\n constructor() {\n this.started = Object.create(null);\n this.times = [];\n }\n\n time(name) {\n if (name in this.started) {\n warn(`Timer is already running for ${name}`);\n }\n this.started[name] = Date.now();\n }\n\n timeEnd(name) {\n if (!(name in this.started)) {\n warn(`Timer has not been started for ${name}`);\n }\n this.times.push({\n name,\n start: this.started[name],\n end: Date.now(),\n });\n // Remove timer from started so it can be called again.\n delete this.started[name];\n }\n\n toString() {\n // Find the longest name for padding purposes.\n const outBuf = [];\n let longest = 0;\n for (const time of this.times) {\n const name = time.name;\n if (name.length > longest) {\n longest = name.length;\n }\n }\n for (const time of this.times) {\n const duration = time.end - time.start;\n outBuf.push(`${time.name.padEnd(longest)} ${duration}ms\\n`);\n }\n return outBuf.join(\"\");\n }\n}\n\nfunction isFetchSupported() {\n return (\n typeof fetch !== \"undefined\" &&\n typeof Response !== \"undefined\" &&\n \"body\" in Response.prototype &&\n typeof ReadableStream !== \"undefined\"\n );\n}\n\nfunction isValidFetchUrl(url, baseUrl) {\n try {\n const { protocol } = baseUrl ? new URL(url, baseUrl) : new URL(url);\n // The Fetch API only supports the http/https protocols, and not file/ftp.\n return protocol === \"http:\" || protocol === \"https:\";\n } catch (ex) {\n return false; // `new URL()` will throw on incorrect data.\n }\n}\n\nfunction loadScript(src) {\n return new Promise((resolve, reject) => {\n const script = document.createElement(\"script\");\n script.src = src;\n\n script.onload = resolve;\n script.onerror = function () {\n reject(new Error(`Cannot load script at: ${script.src}`));\n };\n (document.head || document.documentElement).appendChild(script);\n });\n}\n\n// Deprecated API function -- display regardless of the `verbosity` setting.\nfunction deprecated(details) {\n console.log(\"Deprecated API usage: \" + details);\n}\n\nlet pdfDateStringRegex;\n\nclass PDFDateString {\n /**\n * Convert a PDF date string to a JavaScript `Date` object.\n *\n * The PDF date string format is described in section 7.9.4 of the official\n * PDF 32000-1:2008 specification. However, in the PDF 1.7 reference (sixth\n * edition) Adobe describes the same format including a trailing apostrophe.\n * This syntax in incorrect, but Adobe Acrobat creates PDF files that contain\n * them. We ignore all apostrophes as they are not necessary for date parsing.\n *\n * Moreover, Adobe Acrobat doesn't handle changing the date to universal time\n * and doesn't use the user's time zone (effectively ignoring the HH' and mm'\n * parts of the date string).\n *\n * @param {string} input\n * @returns {Date|null}\n */\n static toDateObject(input) {\n if (!input || !isString(input)) {\n return null;\n }\n\n // Lazily initialize the regular expression.\n if (!pdfDateStringRegex) {\n pdfDateStringRegex = new RegExp(\n \"^D:\" + // Prefix (required)\n \"(\\\\d{4})\" + // Year (required)\n \"(\\\\d{2})?\" + // Month (optional)\n \"(\\\\d{2})?\" + // Day (optional)\n \"(\\\\d{2})?\" + // Hour (optional)\n \"(\\\\d{2})?\" + // Minute (optional)\n \"(\\\\d{2})?\" + // Second (optional)\n \"([Z|+|-])?\" + // Universal time relation (optional)\n \"(\\\\d{2})?\" + // Offset hour (optional)\n \"'?\" + // Splitting apostrophe (optional)\n \"(\\\\d{2})?\" + // Offset minute (optional)\n \"'?\" // Trailing apostrophe (optional)\n );\n }\n\n // Optional fields that don't satisfy the requirements from the regular\n // expression (such as incorrect digit counts or numbers that are out of\n // range) will fall back the defaults from the specification.\n const matches = pdfDateStringRegex.exec(input);\n if (!matches) {\n return null;\n }\n\n // JavaScript's `Date` object expects the month to be between 0 and 11\n // instead of 1 and 12, so we have to correct for that.\n const year = parseInt(matches[1], 10);\n let month = parseInt(matches[2], 10);\n month = month >= 1 && month <= 12 ? month - 1 : 0;\n let day = parseInt(matches[3], 10);\n day = day >= 1 && day <= 31 ? day : 1;\n let hour = parseInt(matches[4], 10);\n hour = hour >= 0 && hour <= 23 ? hour : 0;\n let minute = parseInt(matches[5], 10);\n minute = minute >= 0 && minute <= 59 ? minute : 0;\n let second = parseInt(matches[6], 10);\n second = second >= 0 && second <= 59 ? second : 0;\n const universalTimeRelation = matches[7] || \"Z\";\n let offsetHour = parseInt(matches[8], 10);\n offsetHour = offsetHour >= 0 && offsetHour <= 23 ? offsetHour : 0;\n let offsetMinute = parseInt(matches[9], 10) || 0;\n offsetMinute = offsetMinute >= 0 && offsetMinute <= 59 ? offsetMinute : 0;\n\n // Universal time relation 'Z' means that the local time is equal to the\n // universal time, whereas the relations '+'/'-' indicate that the local\n // time is later respectively earlier than the universal time. Every date\n // is normalized to universal time.\n if (universalTimeRelation === \"-\") {\n hour += offsetHour;\n minute += offsetMinute;\n } else if (universalTimeRelation === \"+\") {\n hour -= offsetHour;\n minute -= offsetMinute;\n }\n\n return new Date(Date.UTC(year, month, day, hour, minute, second));\n }\n}\n\nexport {\n PageViewport,\n RenderingCancelledException,\n addLinkAttributes,\n getFilenameFromUrl,\n LinkTarget,\n DEFAULT_LINK_REL,\n DOMCanvasFactory,\n DOMCMapReaderFactory,\n DOMSVGFactory,\n StatTimer,\n isFetchSupported,\n isValidFetchUrl,\n loadScript,\n deprecated,\n PDFDateString,\n};\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error */\n\nimport \"./compatibility.js\";\n\nconst IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];\nconst FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];\n\n// Permission flags from Table 22, Section 7.6.3.2 of the PDF specification.\nconst PermissionFlag = {\n PRINT: 0x04,\n MODIFY_CONTENTS: 0x08,\n COPY: 0x10,\n MODIFY_ANNOTATIONS: 0x20,\n FILL_INTERACTIVE_FORMS: 0x100,\n COPY_FOR_ACCESSIBILITY: 0x200,\n ASSEMBLE: 0x400,\n PRINT_HIGH_QUALITY: 0x800,\n};\n\nconst TextRenderingMode = {\n FILL: 0,\n STROKE: 1,\n FILL_STROKE: 2,\n INVISIBLE: 3,\n FILL_ADD_TO_PATH: 4,\n STROKE_ADD_TO_PATH: 5,\n FILL_STROKE_ADD_TO_PATH: 6,\n ADD_TO_PATH: 7,\n FILL_STROKE_MASK: 3,\n ADD_TO_PATH_FLAG: 4,\n};\n\nconst ImageKind = {\n GRAYSCALE_1BPP: 1,\n RGB_24BPP: 2,\n RGBA_32BPP: 3,\n};\n\nconst AnnotationType = {\n TEXT: 1,\n LINK: 2,\n FREETEXT: 3,\n LINE: 4,\n SQUARE: 5,\n CIRCLE: 6,\n POLYGON: 7,\n POLYLINE: 8,\n HIGHLIGHT: 9,\n UNDERLINE: 10,\n SQUIGGLY: 11,\n STRIKEOUT: 12,\n STAMP: 13,\n CARET: 14,\n INK: 15,\n POPUP: 16,\n FILEATTACHMENT: 17,\n SOUND: 18,\n MOVIE: 19,\n WIDGET: 20,\n SCREEN: 21,\n PRINTERMARK: 22,\n TRAPNET: 23,\n WATERMARK: 24,\n THREED: 25,\n REDACT: 26,\n};\n\nconst AnnotationStateModelType = {\n MARKED: \"Marked\",\n REVIEW: \"Review\",\n};\n\nconst AnnotationMarkedState = {\n MARKED: \"Marked\",\n UNMARKED: \"Unmarked\",\n};\n\nconst AnnotationReviewState = {\n ACCEPTED: \"Accepted\",\n REJECTED: \"Rejected\",\n CANCELLED: \"Cancelled\",\n COMPLETED: \"Completed\",\n NONE: \"None\",\n};\n\nconst AnnotationReplyType = {\n GROUP: \"Group\",\n REPLY: \"R\",\n};\n\nconst AnnotationFlag = {\n INVISIBLE: 0x01,\n HIDDEN: 0x02,\n PRINT: 0x04,\n NOZOOM: 0x08,\n NOROTATE: 0x10,\n NOVIEW: 0x20,\n READONLY: 0x40,\n LOCKED: 0x80,\n TOGGLENOVIEW: 0x100,\n LOCKEDCONTENTS: 0x200,\n};\n\nconst AnnotationFieldFlag = {\n READONLY: 0x0000001,\n REQUIRED: 0x0000002,\n NOEXPORT: 0x0000004,\n MULTILINE: 0x0001000,\n PASSWORD: 0x0002000,\n NOTOGGLETOOFF: 0x0004000,\n RADIO: 0x0008000,\n PUSHBUTTON: 0x0010000,\n COMBO: 0x0020000,\n EDIT: 0x0040000,\n SORT: 0x0080000,\n FILESELECT: 0x0100000,\n MULTISELECT: 0x0200000,\n DONOTSPELLCHECK: 0x0400000,\n DONOTSCROLL: 0x0800000,\n COMB: 0x1000000,\n RICHTEXT: 0x2000000,\n RADIOSINUNISON: 0x2000000,\n COMMITONSELCHANGE: 0x4000000,\n};\n\nconst AnnotationBorderStyleType = {\n SOLID: 1,\n DASHED: 2,\n BEVELED: 3,\n INSET: 4,\n UNDERLINE: 5,\n};\n\nconst StreamType = {\n UNKNOWN: \"UNKNOWN\",\n FLATE: \"FLATE\",\n LZW: \"LZW\",\n DCT: \"DCT\",\n JPX: \"JPX\",\n JBIG: \"JBIG\",\n A85: \"A85\",\n AHX: \"AHX\",\n CCF: \"CCF\",\n RLX: \"RLX\", // PDF short name is 'RL', but telemetry requires three chars.\n};\n\nconst FontType = {\n UNKNOWN: \"UNKNOWN\",\n TYPE1: \"TYPE1\",\n TYPE1C: \"TYPE1C\",\n CIDFONTTYPE0: \"CIDFONTTYPE0\",\n CIDFONTTYPE0C: \"CIDFONTTYPE0C\",\n TRUETYPE: \"TRUETYPE\",\n CIDFONTTYPE2: \"CIDFONTTYPE2\",\n TYPE3: \"TYPE3\",\n OPENTYPE: \"OPENTYPE\",\n TYPE0: \"TYPE0\",\n MMTYPE1: \"MMTYPE1\",\n};\n\nconst VerbosityLevel = {\n ERRORS: 0,\n WARNINGS: 1,\n INFOS: 5,\n};\n\nconst CMapCompressionType = {\n NONE: 0,\n BINARY: 1,\n STREAM: 2,\n};\n\n// All the possible operations for an operator list.\nconst OPS = {\n // Intentionally start from 1 so it is easy to spot bad operators that will be\n // 0's.\n dependency: 1,\n setLineWidth: 2,\n setLineCap: 3,\n setLineJoin: 4,\n setMiterLimit: 5,\n setDash: 6,\n setRenderingIntent: 7,\n setFlatness: 8,\n setGState: 9,\n save: 10,\n restore: 11,\n transform: 12,\n moveTo: 13,\n lineTo: 14,\n curveTo: 15,\n curveTo2: 16,\n curveTo3: 17,\n closePath: 18,\n rectangle: 19,\n stroke: 20,\n closeStroke: 21,\n fill: 22,\n eoFill: 23,\n fillStroke: 24,\n eoFillStroke: 25,\n closeFillStroke: 26,\n closeEOFillStroke: 27,\n endPath: 28,\n clip: 29,\n eoClip: 30,\n beginText: 31,\n endText: 32,\n setCharSpacing: 33,\n setWordSpacing: 34,\n setHScale: 35,\n setLeading: 36,\n setFont: 37,\n setTextRenderingMode: 38,\n setTextRise: 39,\n moveText: 40,\n setLeadingMoveText: 41,\n setTextMatrix: 42,\n nextLine: 43,\n showText: 44,\n showSpacedText: 45,\n nextLineShowText: 46,\n nextLineSetSpacingShowText: 47,\n setCharWidth: 48,\n setCharWidthAndBounds: 49,\n setStrokeColorSpace: 50,\n setFillColorSpace: 51,\n setStrokeColor: 52,\n setStrokeColorN: 53,\n setFillColor: 54,\n setFillColorN: 55,\n setStrokeGray: 56,\n setFillGray: 57,\n setStrokeRGBColor: 58,\n setFillRGBColor: 59,\n setStrokeCMYKColor: 60,\n setFillCMYKColor: 61,\n shadingFill: 62,\n beginInlineImage: 63,\n beginImageData: 64,\n endInlineImage: 65,\n paintXObject: 66,\n markPoint: 67,\n markPointProps: 68,\n beginMarkedContent: 69,\n beginMarkedContentProps: 70,\n endMarkedContent: 71,\n beginCompat: 72,\n endCompat: 73,\n paintFormXObjectBegin: 74,\n paintFormXObjectEnd: 75,\n beginGroup: 76,\n endGroup: 77,\n beginAnnotations: 78,\n endAnnotations: 79,\n beginAnnotation: 80,\n endAnnotation: 81,\n paintJpegXObject: 82,\n paintImageMaskXObject: 83,\n paintImageMaskXObjectGroup: 84,\n paintImageXObject: 85,\n paintInlineImageXObject: 86,\n paintInlineImageXObjectGroup: 87,\n paintImageXObjectRepeat: 88,\n paintImageMaskXObjectRepeat: 89,\n paintSolidColorImageMask: 90,\n constructPath: 91,\n};\n\nconst UNSUPPORTED_FEATURES = {\n /** @deprecated unused */\n unknown: \"unknown\",\n forms: \"forms\",\n javaScript: \"javaScript\",\n smask: \"smask\",\n shadingPattern: \"shadingPattern\",\n /** @deprecated unused */\n font: \"font\",\n errorTilingPattern: \"errorTilingPattern\",\n errorExtGState: \"errorExtGState\",\n errorXObject: \"errorXObject\",\n errorFontLoadType3: \"errorFontLoadType3\",\n errorFontState: \"errorFontState\",\n errorFontMissing: \"errorFontMissing\",\n errorFontTranslate: \"errorFontTranslate\",\n errorColorSpace: \"errorColorSpace\",\n errorOperatorList: \"errorOperatorList\",\n errorFontToUnicode: \"errorFontToUnicode\",\n errorFontLoadNative: \"errorFontLoadNative\",\n errorFontGetPath: \"errorFontGetPath\",\n};\n\nconst PasswordResponses = {\n NEED_PASSWORD: 1,\n INCORRECT_PASSWORD: 2,\n};\n\nlet verbosity = VerbosityLevel.WARNINGS;\n\nfunction setVerbosityLevel(level) {\n if (Number.isInteger(level)) {\n verbosity = level;\n }\n}\n\nfunction getVerbosityLevel() {\n return verbosity;\n}\n\n// A notice for devs. These are good for things that are helpful to devs, such\n// as warning that Workers were disabled, which is important to devs but not\n// end users.\nfunction info(msg) {\n if (verbosity >= VerbosityLevel.INFOS) {\n console.log(`Info: ${msg}`);\n }\n}\n\n// Non-fatal warnings.\nfunction warn(msg) {\n if (verbosity >= VerbosityLevel.WARNINGS) {\n console.log(`Warning: ${msg}`);\n }\n}\n\nfunction unreachable(msg) {\n throw new Error(msg);\n}\n\nfunction assert(cond, msg) {\n if (!cond) {\n unreachable(msg);\n }\n}\n\n// Checks if URLs have the same origin. For non-HTTP based URLs, returns false.\nfunction isSameOrigin(baseUrl, otherUrl) {\n let base;\n try {\n base = new URL(baseUrl);\n if (!base.origin || base.origin === \"null\") {\n return false; // non-HTTP url\n }\n } catch (e) {\n return false;\n }\n\n const other = new URL(otherUrl, base);\n return base.origin === other.origin;\n}\n\n// Checks if URLs use one of the whitelisted protocols, e.g. to avoid XSS.\nfunction _isValidProtocol(url) {\n if (!url) {\n return false;\n }\n switch (url.protocol) {\n case \"http:\":\n case \"https:\":\n case \"ftp:\":\n case \"mailto:\":\n case \"tel:\":\n return true;\n default:\n return false;\n }\n}\n\n/**\n * Attempts to create a valid absolute URL.\n *\n * @param {URL|string} url - An absolute, or relative, URL.\n * @param {URL|string} baseUrl - An absolute URL.\n * @returns Either a valid {URL}, or `null` otherwise.\n */\nfunction createValidAbsoluteUrl(url, baseUrl) {\n if (!url) {\n return null;\n }\n try {\n const absoluteUrl = baseUrl ? new URL(url, baseUrl) : new URL(url);\n if (_isValidProtocol(absoluteUrl)) {\n return absoluteUrl;\n }\n } catch (ex) {\n /* `new URL()` will throw on incorrect data. */\n }\n return null;\n}\n\nfunction shadow(obj, prop, value) {\n Object.defineProperty(obj, prop, {\n value,\n enumerable: true,\n configurable: true,\n writable: false,\n });\n return value;\n}\n\nconst BaseException = (function BaseExceptionClosure() {\n // eslint-disable-next-line no-shadow\n function BaseException(message) {\n if (this.constructor === BaseException) {\n unreachable(\"Cannot initialize BaseException.\");\n }\n this.message = message;\n this.name = this.constructor.name;\n }\n BaseException.prototype = new Error();\n BaseException.constructor = BaseException;\n\n return BaseException;\n})();\n\nclass PasswordException extends BaseException {\n constructor(msg, code) {\n super(msg);\n this.code = code;\n }\n}\n\nclass UnknownErrorException extends BaseException {\n constructor(msg, details) {\n super(msg);\n this.details = details;\n }\n}\n\nclass InvalidPDFException extends BaseException {}\n\nclass MissingPDFException extends BaseException {}\n\nclass UnexpectedResponseException extends BaseException {\n constructor(msg, status) {\n super(msg);\n this.status = status;\n }\n}\n\n/**\n * Error caused during parsing PDF data.\n */\nclass FormatError extends BaseException {}\n\n/**\n * Error used to indicate task cancellation.\n */\nclass AbortException extends BaseException {}\n\nconst NullCharactersRegExp = /\\x00/g;\n\nfunction removeNullCharacters(str) {\n if (typeof str !== \"string\") {\n warn(\"The argument for removeNullCharacters must be a string.\");\n return str;\n }\n return str.replace(NullCharactersRegExp, \"\");\n}\n\nfunction bytesToString(bytes) {\n assert(\n bytes !== null && typeof bytes === \"object\" && bytes.length !== undefined,\n \"Invalid argument for bytesToString\"\n );\n const length = bytes.length;\n const MAX_ARGUMENT_COUNT = 8192;\n if (length < MAX_ARGUMENT_COUNT) {\n return String.fromCharCode.apply(null, bytes);\n }\n const strBuf = [];\n for (let i = 0; i < length; i += MAX_ARGUMENT_COUNT) {\n const chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);\n const chunk = bytes.subarray(i, chunkEnd);\n strBuf.push(String.fromCharCode.apply(null, chunk));\n }\n return strBuf.join(\"\");\n}\n\nfunction stringToBytes(str) {\n assert(typeof str === \"string\", \"Invalid argument for stringToBytes\");\n const length = str.length;\n const bytes = new Uint8Array(length);\n for (let i = 0; i < length; ++i) {\n bytes[i] = str.charCodeAt(i) & 0xff;\n }\n return bytes;\n}\n\n/**\n * Gets length of the array (Array, Uint8Array, or string) in bytes.\n * @param {Array|Uint8Array|string} arr\n * @returns {number}\n */\nfunction arrayByteLength(arr) {\n if (arr.length !== undefined) {\n return arr.length;\n }\n assert(arr.byteLength !== undefined, \"arrayByteLength - invalid argument.\");\n return arr.byteLength;\n}\n\n/**\n * Combines array items (arrays) into single Uint8Array object.\n * @param {Array} arr - the array of the arrays (Array, Uint8Array, or string).\n * @returns {Uint8Array}\n */\nfunction arraysToBytes(arr) {\n const length = arr.length;\n // Shortcut: if first and only item is Uint8Array, return it.\n if (length === 1 && arr[0] instanceof Uint8Array) {\n return arr[0];\n }\n let resultLength = 0;\n for (let i = 0; i < length; i++) {\n resultLength += arrayByteLength(arr[i]);\n }\n let pos = 0;\n const data = new Uint8Array(resultLength);\n for (let i = 0; i < length; i++) {\n let item = arr[i];\n if (!(item instanceof Uint8Array)) {\n if (typeof item === \"string\") {\n item = stringToBytes(item);\n } else {\n item = new Uint8Array(item);\n }\n }\n const itemLength = item.byteLength;\n data.set(item, pos);\n pos += itemLength;\n }\n return data;\n}\n\nfunction string32(value) {\n return String.fromCharCode(\n (value >> 24) & 0xff,\n (value >> 16) & 0xff,\n (value >> 8) & 0xff,\n value & 0xff\n );\n}\n\n// Checks the endianness of the platform.\nfunction isLittleEndian() {\n const buffer8 = new Uint8Array(4);\n buffer8[0] = 1;\n const view32 = new Uint32Array(buffer8.buffer, 0, 1);\n return view32[0] === 1;\n}\nconst IsLittleEndianCached = {\n get value() {\n return shadow(this, \"value\", isLittleEndian());\n },\n};\n\n// Checks if it's possible to eval JS expressions.\nfunction isEvalSupported() {\n try {\n new Function(\"\"); // eslint-disable-line no-new, no-new-func\n return true;\n } catch (e) {\n return false;\n }\n}\nconst IsEvalSupportedCached = {\n get value() {\n return shadow(this, \"value\", isEvalSupported());\n },\n};\n\nconst rgbBuf = [\"rgb(\", 0, \",\", 0, \",\", 0, \")\"];\n\nclass Util {\n // makeCssRgb() can be called thousands of times. Using ´rgbBuf` avoids\n // creating many intermediate strings.\n static makeCssRgb(r, g, b) {\n rgbBuf[1] = r;\n rgbBuf[3] = g;\n rgbBuf[5] = b;\n return rgbBuf.join(\"\");\n }\n\n // Concatenates two transformation matrices together and returns the result.\n static transform(m1, m2) {\n return [\n m1[0] * m2[0] + m1[2] * m2[1],\n m1[1] * m2[0] + m1[3] * m2[1],\n m1[0] * m2[2] + m1[2] * m2[3],\n m1[1] * m2[2] + m1[3] * m2[3],\n m1[0] * m2[4] + m1[2] * m2[5] + m1[4],\n m1[1] * m2[4] + m1[3] * m2[5] + m1[5],\n ];\n }\n\n // For 2d affine transforms\n static applyTransform(p, m) {\n const xt = p[0] * m[0] + p[1] * m[2] + m[4];\n const yt = p[0] * m[1] + p[1] * m[3] + m[5];\n return [xt, yt];\n }\n\n static applyInverseTransform(p, m) {\n const d = m[0] * m[3] - m[1] * m[2];\n const xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;\n const yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;\n return [xt, yt];\n }\n\n // Applies the transform to the rectangle and finds the minimum axially\n // aligned bounding box.\n static getAxialAlignedBoundingBox(r, m) {\n const p1 = Util.applyTransform(r, m);\n const p2 = Util.applyTransform(r.slice(2, 4), m);\n const p3 = Util.applyTransform([r[0], r[3]], m);\n const p4 = Util.applyTransform([r[2], r[1]], m);\n return [\n Math.min(p1[0], p2[0], p3[0], p4[0]),\n Math.min(p1[1], p2[1], p3[1], p4[1]),\n Math.max(p1[0], p2[0], p3[0], p4[0]),\n Math.max(p1[1], p2[1], p3[1], p4[1]),\n ];\n }\n\n static inverseTransform(m) {\n const d = m[0] * m[3] - m[1] * m[2];\n return [\n m[3] / d,\n -m[1] / d,\n -m[2] / d,\n m[0] / d,\n (m[2] * m[5] - m[4] * m[3]) / d,\n (m[4] * m[1] - m[5] * m[0]) / d,\n ];\n }\n\n // Apply a generic 3d matrix M on a 3-vector v:\n // | a b c | | X |\n // | d e f | x | Y |\n // | g h i | | Z |\n // M is assumed to be serialized as [a,b,c,d,e,f,g,h,i],\n // with v as [X,Y,Z]\n static apply3dTransform(m, v) {\n return [\n m[0] * v[0] + m[1] * v[1] + m[2] * v[2],\n m[3] * v[0] + m[4] * v[1] + m[5] * v[2],\n m[6] * v[0] + m[7] * v[1] + m[8] * v[2],\n ];\n }\n\n // This calculation uses Singular Value Decomposition.\n // The SVD can be represented with formula A = USV. We are interested in the\n // matrix S here because it represents the scale values.\n static singularValueDecompose2dScale(m) {\n const transpose = [m[0], m[2], m[1], m[3]];\n\n // Multiply matrix m with its transpose.\n const a = m[0] * transpose[0] + m[1] * transpose[2];\n const b = m[0] * transpose[1] + m[1] * transpose[3];\n const c = m[2] * transpose[0] + m[3] * transpose[2];\n const d = m[2] * transpose[1] + m[3] * transpose[3];\n\n // Solve the second degree polynomial to get roots.\n const first = (a + d) / 2;\n const second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;\n const sx = first + second || 1;\n const sy = first - second || 1;\n\n // Scale values are the square roots of the eigenvalues.\n return [Math.sqrt(sx), Math.sqrt(sy)];\n }\n\n // Normalize rectangle rect=[x1, y1, x2, y2] so that (x1,y1) < (x2,y2)\n // For coordinate systems whose origin lies in the bottom-left, this\n // means normalization to (BL,TR) ordering. For systems with origin in the\n // top-left, this means (TL,BR) ordering.\n static normalizeRect(rect) {\n const r = rect.slice(0); // clone rect\n if (rect[0] > rect[2]) {\n r[0] = rect[2];\n r[2] = rect[0];\n }\n if (rect[1] > rect[3]) {\n r[1] = rect[3];\n r[3] = rect[1];\n }\n return r;\n }\n\n // Returns a rectangle [x1, y1, x2, y2] corresponding to the\n // intersection of rect1 and rect2. If no intersection, returns 'false'\n // The rectangle coordinates of rect1, rect2 should be [x1, y1, x2, y2]\n static intersect(rect1, rect2) {\n function compare(a, b) {\n return a - b;\n }\n\n // Order points along the axes\n const orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare);\n const orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare);\n const result = [];\n\n rect1 = Util.normalizeRect(rect1);\n rect2 = Util.normalizeRect(rect2);\n\n // X: first and second points belong to different rectangles?\n if (\n (orderedX[0] === rect1[0] && orderedX[1] === rect2[0]) ||\n (orderedX[0] === rect2[0] && orderedX[1] === rect1[0])\n ) {\n // Intersection must be between second and third points\n result[0] = orderedX[1];\n result[2] = orderedX[2];\n } else {\n return null;\n }\n\n // Y: first and second points belong to different rectangles?\n if (\n (orderedY[0] === rect1[1] && orderedY[1] === rect2[1]) ||\n (orderedY[0] === rect2[1] && orderedY[1] === rect1[1])\n ) {\n // Intersection must be between second and third points\n result[1] = orderedY[1];\n result[3] = orderedY[2];\n } else {\n return null;\n }\n\n return result;\n }\n}\n\n// prettier-ignore\nconst PDFStringTranslateTable = [\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n 0x2D8, 0x2C7, 0x2C6, 0x2D9, 0x2DD, 0x2DB, 0x2DA, 0x2DC, 0, 0, 0, 0, 0, 0, 0,\n 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,\n 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,\n 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,\n 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014,\n 0x2013, 0x192, 0x2044, 0x2039, 0x203A, 0x2212, 0x2030, 0x201E, 0x201C,\n 0x201D, 0x2018, 0x2019, 0x201A, 0x2122, 0xFB01, 0xFB02, 0x141, 0x152, 0x160,\n 0x178, 0x17D, 0x131, 0x142, 0x153, 0x161, 0x17E, 0, 0x20AC\n];\n\nfunction stringToPDFString(str) {\n const length = str.length,\n strBuf = [];\n if (str[0] === \"\\xFE\" && str[1] === \"\\xFF\") {\n // UTF16BE BOM\n for (let i = 2; i < length; i += 2) {\n strBuf.push(\n String.fromCharCode((str.charCodeAt(i) << 8) | str.charCodeAt(i + 1))\n );\n }\n } else if (str[0] === \"\\xFF\" && str[1] === \"\\xFE\") {\n // UTF16LE BOM\n for (let i = 2; i < length; i += 2) {\n strBuf.push(\n String.fromCharCode((str.charCodeAt(i + 1) << 8) | str.charCodeAt(i))\n );\n }\n } else {\n for (let i = 0; i < length; ++i) {\n const code = PDFStringTranslateTable[str.charCodeAt(i)];\n strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));\n }\n }\n return strBuf.join(\"\");\n}\n\nfunction stringToUTF8String(str) {\n return decodeURIComponent(escape(str));\n}\n\nfunction utf8StringToString(str) {\n return unescape(encodeURIComponent(str));\n}\n\nfunction isEmptyObj(obj) {\n for (const key in obj) {\n return false;\n }\n return true;\n}\n\nfunction isBool(v) {\n return typeof v === \"boolean\";\n}\n\nfunction isNum(v) {\n return typeof v === \"number\";\n}\n\nfunction isString(v) {\n return typeof v === \"string\";\n}\n\nfunction isArrayBuffer(v) {\n return typeof v === \"object\" && v !== null && v.byteLength !== undefined;\n}\n\nfunction isArrayEqual(arr1, arr2) {\n if (arr1.length !== arr2.length) {\n return false;\n }\n return arr1.every(function (element, index) {\n return element === arr2[index];\n });\n}\n\n/**\n * Promise Capability object.\n *\n * @typedef {Object} PromiseCapability\n * @property {Promise} promise - A Promise object.\n * @property {boolean} settled - If the Promise has been fulfilled/rejected.\n * @property {function} resolve - Fulfills the Promise.\n * @property {function} reject - Rejects the Promise.\n */\n\n/**\n * Creates a promise capability object.\n * @alias createPromiseCapability\n *\n * @returns {PromiseCapability}\n */\nfunction createPromiseCapability() {\n const capability = Object.create(null);\n let isSettled = false;\n\n Object.defineProperty(capability, \"settled\", {\n get() {\n return isSettled;\n },\n });\n capability.promise = new Promise(function (resolve, reject) {\n capability.resolve = function (data) {\n isSettled = true;\n resolve(data);\n };\n capability.reject = function (reason) {\n isSettled = true;\n reject(reason);\n };\n });\n return capability;\n}\n\nconst createObjectURL = (function createObjectURLClosure() {\n // Blob/createObjectURL is not available, falling back to data schema.\n const digits =\n \"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=\";\n\n // eslint-disable-next-line no-shadow\n return function createObjectURL(data, contentType, forceDataSchema = false) {\n if (!forceDataSchema && URL.createObjectURL) {\n const blob = new Blob([data], { type: contentType });\n return URL.createObjectURL(blob);\n }\n\n let buffer = `data:${contentType};base64,`;\n for (let i = 0, ii = data.length; i < ii; i += 3) {\n const b1 = data[i] & 0xff;\n const b2 = data[i + 1] & 0xff;\n const b3 = data[i + 2] & 0xff;\n const d1 = b1 >> 2,\n d2 = ((b1 & 3) << 4) | (b2 >> 4);\n const d3 = i + 1 < ii ? ((b2 & 0xf) << 2) | (b3 >> 6) : 64;\n const d4 = i + 2 < ii ? b3 & 0x3f : 64;\n buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];\n }\n return buffer;\n };\n})();\n\nexport {\n BaseException,\n FONT_IDENTITY_MATRIX,\n IDENTITY_MATRIX,\n OPS,\n VerbosityLevel,\n UNSUPPORTED_FEATURES,\n AnnotationBorderStyleType,\n AnnotationFieldFlag,\n AnnotationFlag,\n AnnotationMarkedState,\n AnnotationReplyType,\n AnnotationReviewState,\n AnnotationStateModelType,\n AnnotationType,\n FontType,\n ImageKind,\n CMapCompressionType,\n AbortException,\n InvalidPDFException,\n MissingPDFException,\n PasswordException,\n PasswordResponses,\n PermissionFlag,\n StreamType,\n TextRenderingMode,\n UnexpectedResponseException,\n UnknownErrorException,\n Util,\n FormatError,\n arrayByteLength,\n arraysToBytes,\n assert,\n bytesToString,\n createPromiseCapability,\n createObjectURL,\n getVerbosityLevel,\n info,\n isArrayBuffer,\n isArrayEqual,\n isBool,\n isEmptyObj,\n isNum,\n isString,\n isSameOrigin,\n createValidAbsoluteUrl,\n IsLittleEndianCached,\n IsEvalSupportedCached,\n removeNullCharacters,\n setVerbosityLevel,\n shadow,\n string32,\n stringToBytes,\n stringToPDFString,\n stringToUTF8String,\n utf8StringToString,\n warn,\n unreachable,\n};\n","/* Copyright 2017 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error */\n\nimport { isNodeJS } from \"./is_node.js\";\n\n// Skip compatibility checks for modern builds and if we already ran the module.\nif (\n (typeof PDFJSDev === \"undefined\" || !PDFJSDev.test(\"SKIP_BABEL\")) &&\n (typeof globalThis === \"undefined\" || !globalThis._pdfjsCompatibilityChecked)\n) {\n // Provides support for globalThis in legacy browsers.\n // Support: IE11/Edge, Opera\n if (typeof globalThis === \"undefined\" || globalThis.Math !== Math) {\n // eslint-disable-next-line no-global-assign\n globalThis = require(\"core-js/es/global-this\");\n }\n globalThis._pdfjsCompatibilityChecked = true;\n\n const hasDOM = typeof window === \"object\" && typeof document === \"object\";\n const userAgent =\n (typeof navigator !== \"undefined\" && navigator.userAgent) || \"\";\n const isIE = /Trident/.test(userAgent);\n\n // Support: Node.js\n (function checkNodeBtoa() {\n if (globalThis.btoa || !isNodeJS) {\n return;\n }\n globalThis.btoa = function (chars) {\n // eslint-disable-next-line no-undef\n return Buffer.from(chars, \"binary\").toString(\"base64\");\n };\n })();\n\n // Support: Node.js\n (function checkNodeAtob() {\n if (globalThis.atob || !isNodeJS) {\n return;\n }\n globalThis.atob = function (input) {\n // eslint-disable-next-line no-undef\n return Buffer.from(input, \"base64\").toString(\"binary\");\n };\n })();\n\n // Provides support for ChildNode.remove in legacy browsers.\n // Support: IE.\n (function checkChildNodeRemove() {\n if (!hasDOM) {\n return;\n }\n if (typeof Element.prototype.remove !== \"undefined\") {\n return;\n }\n Element.prototype.remove = function () {\n if (this.parentNode) {\n // eslint-disable-next-line mozilla/avoid-removeChild\n this.parentNode.removeChild(this);\n }\n };\n })();\n\n // Provides support for DOMTokenList.prototype.{add, remove}, with more than\n // one parameter, in legacy browsers.\n // Support: IE\n (function checkDOMTokenListAddRemove() {\n if (!hasDOM || isNodeJS) {\n return;\n }\n const div = document.createElement(\"div\");\n div.classList.add(\"testOne\", \"testTwo\");\n\n if (\n div.classList.contains(\"testOne\") === true &&\n div.classList.contains(\"testTwo\") === true\n ) {\n return;\n }\n const OriginalDOMTokenListAdd = DOMTokenList.prototype.add;\n const OriginalDOMTokenListRemove = DOMTokenList.prototype.remove;\n\n DOMTokenList.prototype.add = function (...tokens) {\n for (const token of tokens) {\n OriginalDOMTokenListAdd.call(this, token);\n }\n };\n DOMTokenList.prototype.remove = function (...tokens) {\n for (const token of tokens) {\n OriginalDOMTokenListRemove.call(this, token);\n }\n };\n })();\n\n // Provides support for DOMTokenList.prototype.toggle, with the optional\n // \"force\" parameter, in legacy browsers.\n // Support: IE\n (function checkDOMTokenListToggle() {\n if (!hasDOM || isNodeJS) {\n return;\n }\n const div = document.createElement(\"div\");\n if (div.classList.toggle(\"test\", 0) === false) {\n return;\n }\n\n DOMTokenList.prototype.toggle = function (token) {\n const force =\n arguments.length > 1 ? !!arguments[1] : !this.contains(token);\n return this[force ? \"add\" : \"remove\"](token), force;\n };\n })();\n\n // Provides support for window.history.{pushState, replaceState}, with the\n // `url` parameter set to `undefined`, without breaking the document URL.\n // Support: IE\n (function checkWindowHistoryPushStateReplaceState() {\n if (!hasDOM || !isIE) {\n return;\n }\n const OriginalPushState = window.history.pushState;\n const OriginalReplaceState = window.history.replaceState;\n\n window.history.pushState = function (state, title, url) {\n const args = url === undefined ? [state, title] : [state, title, url];\n OriginalPushState.apply(this, args);\n };\n window.history.replaceState = function (state, title, url) {\n const args = url === undefined ? [state, title] : [state, title, url];\n OriginalReplaceState.apply(this, args);\n };\n })();\n\n // Provides support for String.prototype.startsWith in legacy browsers.\n // Support: IE, Chrome<41\n (function checkStringStartsWith() {\n if (String.prototype.startsWith) {\n return;\n }\n require(\"core-js/es/string/starts-with.js\");\n })();\n\n // Provides support for String.prototype.endsWith in legacy browsers.\n // Support: IE, Chrome<41\n (function checkStringEndsWith() {\n if (String.prototype.endsWith) {\n return;\n }\n require(\"core-js/es/string/ends-with.js\");\n })();\n\n // Provides support for String.prototype.includes in legacy browsers.\n // Support: IE, Chrome<41\n (function checkStringIncludes() {\n if (String.prototype.includes) {\n return;\n }\n require(\"core-js/es/string/includes.js\");\n })();\n\n // Provides support for Array.prototype.includes in legacy browsers.\n // Support: IE, Chrome<47\n (function checkArrayIncludes() {\n if (Array.prototype.includes) {\n return;\n }\n require(\"core-js/es/array/includes.js\");\n })();\n\n // Provides support for Array.from in legacy browsers.\n // Support: IE\n (function checkArrayFrom() {\n if (Array.from) {\n return;\n }\n require(\"core-js/es/array/from.js\");\n })();\n\n // Provides support for Object.assign in legacy browsers.\n // Support: IE\n (function checkObjectAssign() {\n if (Object.assign) {\n return;\n }\n require(\"core-js/es/object/assign.js\");\n })();\n\n // Provides support for Math.log2 in legacy browsers.\n // Support: IE, Chrome<38\n (function checkMathLog2() {\n if (Math.log2) {\n return;\n }\n Math.log2 = require(\"core-js/es/math/log2.js\");\n })();\n\n // Provides support for Number.isNaN in legacy browsers.\n // Support: IE.\n (function checkNumberIsNaN() {\n if (Number.isNaN) {\n return;\n }\n Number.isNaN = require(\"core-js/es/number/is-nan.js\");\n })();\n\n // Provides support for Number.isInteger in legacy browsers.\n // Support: IE, Chrome<34\n (function checkNumberIsInteger() {\n if (Number.isInteger) {\n return;\n }\n Number.isInteger = require(\"core-js/es/number/is-integer.js\");\n })();\n\n // Provides support for TypedArray.prototype.slice in legacy browsers.\n // Support: IE\n (function checkTypedArraySlice() {\n if (Uint8Array.prototype.slice) {\n return;\n }\n require(\"core-js/es/typed-array/slice\");\n })();\n\n // Support: IE, Safari<11, Chrome<63\n (function checkPromise() {\n if (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"IMAGE_DECODERS\")) {\n // The current image decoders are synchronous, hence `Promise` shouldn't\n // need to be polyfilled for the IMAGE_DECODERS build target.\n return;\n }\n if (globalThis.Promise && globalThis.Promise.allSettled) {\n return;\n }\n globalThis.Promise = require(\"core-js/es/promise/index.js\");\n })();\n\n // Support: IE\n (function checkURL() {\n if (typeof PDFJSDev === \"undefined\" || !PDFJSDev.test(\"PRODUCTION\")) {\n // Prevent \"require is not a function\" errors in development mode,\n // since the `URL` constructor should be available in modern browers.\n return;\n } else if (!PDFJSDev.test(\"GENERIC\")) {\n // The `URL` constructor is assumed to be available in the extension\n // builds.\n return;\n } else if (PDFJSDev.test(\"IMAGE_DECODERS\")) {\n // The current image decoders don't use the `URL` constructor, so it\n // doesn't need to be polyfilled for the IMAGE_DECODERS build target.\n return;\n }\n globalThis.URL = require(\"core-js/web/url.js\");\n })();\n\n // Support: IE, Node.js\n (function checkReadableStream() {\n if (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"IMAGE_DECODERS\")) {\n // The current image decoders are synchronous, hence `ReadableStream`\n // shouldn't need to be polyfilled for the IMAGE_DECODERS build target.\n return;\n }\n let isReadableStreamSupported = false;\n\n if (typeof ReadableStream !== \"undefined\") {\n // MS Edge may say it has ReadableStream but they are not up to spec yet.\n try {\n // eslint-disable-next-line no-new\n new ReadableStream({\n start(controller) {\n controller.close();\n },\n });\n isReadableStreamSupported = true;\n } catch (e) {\n // The ReadableStream constructor cannot be used.\n }\n }\n if (isReadableStreamSupported) {\n return;\n }\n globalThis.ReadableStream = require(\"web-streams-polyfill/dist/ponyfill.js\").ReadableStream;\n })();\n\n // We want to support Map iteration, but it doesn't seem possible to easily\n // test for that specifically; hence using a similarly unsupported property.\n // Support: IE11\n (function checkMapEntries() {\n if (globalThis.Map && globalThis.Map.prototype.entries) {\n return;\n }\n globalThis.Map = require(\"core-js/es/map/index.js\");\n })();\n\n // We want to support Set iteration, but it doesn't seem possible to easily\n // test for that specifically; hence using a similarly unsupported property.\n // Support: IE11\n (function checkSetEntries() {\n if (globalThis.Set && globalThis.Set.prototype.entries) {\n return;\n }\n globalThis.Set = require(\"core-js/es/set/index.js\");\n })();\n\n // Support: IE<11, Safari<8, Chrome<36\n (function checkWeakMap() {\n if (globalThis.WeakMap) {\n return;\n }\n globalThis.WeakMap = require(\"core-js/es/weak-map/index.js\");\n })();\n\n // Support: IE11\n (function checkWeakSet() {\n if (globalThis.WeakSet) {\n return;\n }\n globalThis.WeakSet = require(\"core-js/es/weak-set/index.js\");\n })();\n\n // Provides support for String.codePointAt in legacy browsers.\n // Support: IE11.\n (function checkStringCodePointAt() {\n if (String.prototype.codePointAt) {\n return;\n }\n require(\"core-js/es/string/code-point-at.js\");\n })();\n\n // Provides support for String.fromCodePoint in legacy browsers.\n // Support: IE11.\n (function checkStringFromCodePoint() {\n if (String.fromCodePoint) {\n return;\n }\n String.fromCodePoint = require(\"core-js/es/string/from-code-point.js\");\n })();\n\n // Support: IE\n (function checkSymbol() {\n if (globalThis.Symbol) {\n return;\n }\n require(\"core-js/es/symbol/index.js\");\n })();\n\n // Provides support for String.prototype.padStart in legacy browsers.\n // Support: IE, Chrome<57\n (function checkStringPadStart() {\n if (String.prototype.padStart) {\n return;\n }\n require(\"core-js/es/string/pad-start.js\");\n })();\n\n // Provides support for String.prototype.padEnd in legacy browsers.\n // Support: IE, Chrome<57\n (function checkStringPadEnd() {\n if (String.prototype.padEnd) {\n return;\n }\n require(\"core-js/es/string/pad-end.js\");\n })();\n\n // Provides support for Object.values in legacy browsers.\n // Support: IE, Chrome<54\n (function checkObjectValues() {\n if (Object.values) {\n return;\n }\n Object.values = require(\"core-js/es/object/values.js\");\n })();\n}\n","/* Copyright 2018 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* globals process */\n\n// NW.js / Electron is a browser context, but copies some Node.js objects; see\n// http://docs.nwjs.io/en/latest/For%20Users/Advanced/JavaScript%20Contexts%20in%20NW.js/#access-nodejs-and-nwjs-api-in-browser-context\n// https://electronjs.org/docs/api/process#processversionselectron\nconst isNodeJS =\n typeof process === \"object\" &&\n process + \"\" === \"[object process]\" &&\n !process.versions.nw &&\n !process.versions.electron;\n\nexport { isNodeJS };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error */\n\n/**\n * @module pdfjsLib\n */\n\nimport {\n AbortException,\n assert,\n createPromiseCapability,\n getVerbosityLevel,\n info,\n InvalidPDFException,\n isArrayBuffer,\n isSameOrigin,\n MissingPDFException,\n PasswordException,\n setVerbosityLevel,\n shadow,\n stringToBytes,\n UnexpectedResponseException,\n UnknownErrorException,\n unreachable,\n warn,\n} from \"../shared/util.js\";\nimport {\n deprecated,\n DOMCanvasFactory,\n DOMCMapReaderFactory,\n loadScript,\n PageViewport,\n RenderingCancelledException,\n StatTimer,\n} from \"./display_utils.js\";\nimport { FontFaceObject, FontLoader } from \"./font_loader.js\";\nimport { apiCompatibilityParams } from \"./api_compatibility.js\";\nimport { CanvasGraphics } from \"./canvas.js\";\nimport { GlobalWorkerOptions } from \"./worker_options.js\";\nimport { isNodeJS } from \"../shared/is_node.js\";\nimport { MessageHandler } from \"../shared/message_handler.js\";\nimport { Metadata } from \"./metadata.js\";\nimport { PDFDataTransportStream } from \"./transport_stream.js\";\nimport { WebGLContext } from \"./webgl.js\";\n\nconst DEFAULT_RANGE_CHUNK_SIZE = 65536; // 2^16 = 65536\nconst RENDERING_CANCELLED_TIMEOUT = 100; // ms\n\n/**\n * @typedef {function} IPDFStreamFactory\n * @param {DocumentInitParameters} params - The document initialization\n * parameters. The \"url\" key is always present.\n * @returns {Promise} A promise, which is resolved with an instance of\n * {IPDFStream}.\n * @ignore\n */\n\n/**\n * @type IPDFStreamFactory\n * @private\n */\nlet createPDFNetworkStream;\n\n/**\n * Sets the function that instantiates an {IPDFStream} as an alternative PDF\n * data transport.\n * @param {IPDFStreamFactory} pdfNetworkStreamFactory - The factory function\n * that takes document initialization parameters (including a \"url\") and\n * returns a promise which is resolved with an instance of {IPDFStream}.\n * @ignore\n */\nfunction setPDFNetworkStreamFactory(pdfNetworkStreamFactory) {\n createPDFNetworkStream = pdfNetworkStreamFactory;\n}\n\n/**\n * Document initialization / loading parameters object.\n *\n * @typedef {Object} DocumentInitParameters\n * @property {string} [url] - The URL of the PDF.\n * @property {TypedArray|Array|string} [data] - Binary PDF data. Use typed\n * arrays (Uint8Array) to improve the memory usage. If PDF data is\n * BASE64-encoded, use atob() to convert it to a binary string first.\n * @property {Object} [httpHeaders] - Basic authentication headers.\n * @property {boolean} [withCredentials] - Indicates whether or not\n * cross-site Access-Control requests should be made using credentials such\n * as cookies or authorization headers. The default is false.\n * @property {string} [password] - For decrypting password-protected PDFs.\n * @property {TypedArray} [initialData] - A typed array with the first portion\n * or all of the pdf data. Used by the extension since some data is already\n * loaded before the switch to range requests.\n * @property {number} [length] - The PDF file length. It's used for\n * progress reports and range requests operations.\n * @property {PDFDataRangeTransport} [range]\n * @property {number} [rangeChunkSize] - Specify maximum number of bytes\n * fetched per range request. The default value is 2^16 = 65536.\n * @property {PDFWorker} [worker] - The worker that will be used for\n * the loading and parsing of the PDF data.\n * @property {number} [verbosity] - Controls the logging level; the\n * constants from {VerbosityLevel} should be used.\n * @property {string} [docBaseUrl] - The base URL of the document,\n * used when attempting to recover valid absolute URLs for annotations, and\n * outline items, that (incorrectly) only specify relative URLs.\n * @property {string} [cMapUrl] - The URL where the predefined\n * Adobe CMaps are located. Include trailing slash.\n * @property {boolean} [cMapPacked] - Specifies if the Adobe CMaps are\n * binary packed.\n * @property {Object} [CMapReaderFactory] - The factory that will be\n * used when reading built-in CMap files. Providing a custom factory is useful\n * for environments without `XMLHttpRequest` support, such as e.g. Node.js.\n * The default value is {DOMCMapReaderFactory}.\n * @property {boolean} [stopAtErrors] - Reject certain promises, e.g.\n * `getOperatorList`, `getTextContent`, and `RenderTask`, when the associated\n * PDF data cannot be successfully parsed, instead of attempting to recover\n * whatever possible of the data. The default value is `false`.\n * @property {number} [maxImageSize] - The maximum allowed image size\n * in total pixels, i.e. width * height. Images above this value will not be\n * rendered. Use -1 for no limit, which is also the default value.\n * @property {boolean} [isEvalSupported] - Determines if we can eval\n * strings as JS. Primarily used to improve performance of font rendering,\n * and when parsing PDF functions. The default value is `true`.\n * @property {boolean} [disableFontFace] - By default fonts are\n * converted to OpenType fonts and loaded via font face rules. If disabled,\n * fonts will be rendered using a built-in font renderer that constructs the\n * glyphs with primitive path commands. The default value is `false`.\n * @property {boolean} [fontExtraProperties] - Include additional properties,\n * which are unused during rendering of PDF documents, when exporting the\n * parsed font data from the worker-thread. This may be useful for debugging\n * purposes (and backwards compatibility), but note that it will lead to\n * increased memory usage. The default value is `false`.\n * @property {boolean} [disableRange] - Disable range request loading\n * of PDF files. When enabled, and if the server supports partial content\n * requests, then the PDF will be fetched in chunks.\n * The default value is `false`.\n * @property {boolean} [disableStream] - Disable streaming of PDF file\n * data. By default PDF.js attempts to load PDFs in chunks.\n * The default value is `false`.\n * @property {boolean} [disableAutoFetch] - Disable pre-fetching of PDF\n * file data. When range requests are enabled PDF.js will automatically keep\n * fetching more data even if it isn't needed to display the current page.\n * The default value is `false`.\n * NOTE: It is also necessary to disable streaming, see above,\n * in order for disabling of pre-fetching to work correctly.\n * @property {boolean} [pdfBug] - Enables special hooks for debugging\n * PDF.js (see `web/debugger.js`). The default value is `false`.\n */\n\n/**\n * @typedef {Object} PDFDocumentStats\n * @property {Object} streamTypes - Used stream types in the document (an item\n * is set to true if specific stream ID was used in the document).\n * @property {Object} fontTypes - Used font types in the document (an item\n * is set to true if specific font ID was used in the document).\n */\n\n/**\n * This is the main entry point for loading a PDF and interacting with it.\n * NOTE: If a URL is used to fetch the PDF data a standard XMLHttpRequest(XHR)\n * is used, which means it must follow the same origin rules that any XHR does\n * e.g. No cross domain requests without CORS.\n *\n * @param {string|TypedArray|DocumentInitParameters|PDFDataRangeTransport} src\n * Can be a url to where a PDF is located, a typed array (Uint8Array)\n * already populated with data or parameter object.\n * @returns {PDFDocumentLoadingTask}\n */\nfunction getDocument(src) {\n const task = new PDFDocumentLoadingTask();\n\n let source;\n if (typeof src === \"string\") {\n source = { url: src };\n } else if (isArrayBuffer(src)) {\n source = { data: src };\n } else if (src instanceof PDFDataRangeTransport) {\n source = { range: src };\n } else {\n if (typeof src !== \"object\") {\n throw new Error(\n \"Invalid parameter in getDocument, \" +\n \"need either Uint8Array, string or a parameter object\"\n );\n }\n if (!src.url && !src.data && !src.range) {\n throw new Error(\n \"Invalid parameter object: need either .data, .range or .url\"\n );\n }\n source = src;\n }\n const params = Object.create(null);\n let rangeTransport = null,\n worker = null;\n\n for (const key in source) {\n if (key === \"url\" && typeof window !== \"undefined\") {\n // The full path is required in the 'url' field.\n params[key] = new URL(source[key], window.location).href;\n continue;\n } else if (key === \"range\") {\n rangeTransport = source[key];\n continue;\n } else if (key === \"worker\") {\n worker = source[key];\n continue;\n } else if (key === \"data\" && !(source[key] instanceof Uint8Array)) {\n // Converting string or array-like data to Uint8Array.\n const pdfBytes = source[key];\n if (typeof pdfBytes === \"string\") {\n params[key] = stringToBytes(pdfBytes);\n } else if (\n typeof pdfBytes === \"object\" &&\n pdfBytes !== null &&\n !isNaN(pdfBytes.length)\n ) {\n params[key] = new Uint8Array(pdfBytes);\n } else if (isArrayBuffer(pdfBytes)) {\n params[key] = new Uint8Array(pdfBytes);\n } else {\n throw new Error(\n \"Invalid PDF binary data: either typed array, \" +\n \"string or array-like object is expected in the \" +\n \"data property.\"\n );\n }\n continue;\n }\n params[key] = source[key];\n }\n\n params.rangeChunkSize = params.rangeChunkSize || DEFAULT_RANGE_CHUNK_SIZE;\n params.CMapReaderFactory = params.CMapReaderFactory || DOMCMapReaderFactory;\n params.ignoreErrors = params.stopAtErrors !== true;\n params.fontExtraProperties = params.fontExtraProperties === true;\n params.pdfBug = params.pdfBug === true;\n\n if (!Number.isInteger(params.maxImageSize)) {\n params.maxImageSize = -1;\n }\n if (typeof params.isEvalSupported !== \"boolean\") {\n params.isEvalSupported = true;\n }\n if (typeof params.disableFontFace !== \"boolean\") {\n params.disableFontFace = apiCompatibilityParams.disableFontFace || false;\n }\n\n if (typeof params.disableRange !== \"boolean\") {\n params.disableRange = false;\n }\n if (typeof params.disableStream !== \"boolean\") {\n params.disableStream = false;\n }\n if (typeof params.disableAutoFetch !== \"boolean\") {\n params.disableAutoFetch = false;\n }\n\n // Set the main-thread verbosity level.\n setVerbosityLevel(params.verbosity);\n\n if (!worker) {\n const workerParams = {\n verbosity: params.verbosity,\n port: GlobalWorkerOptions.workerPort,\n };\n // Worker was not provided -- creating and owning our own. If message port\n // is specified in global worker options, using it.\n worker = workerParams.port\n ? PDFWorker.fromPort(workerParams)\n : new PDFWorker(workerParams);\n task._worker = worker;\n }\n const docId = task.docId;\n worker.promise\n .then(function () {\n if (task.destroyed) {\n throw new Error(\"Loading aborted\");\n }\n\n const workerIdPromise = _fetchDocument(\n worker,\n params,\n rangeTransport,\n docId\n );\n const networkStreamPromise = new Promise(function (resolve) {\n let networkStream;\n if (rangeTransport) {\n networkStream = new PDFDataTransportStream(\n {\n length: params.length,\n initialData: params.initialData,\n progressiveDone: params.progressiveDone,\n disableRange: params.disableRange,\n disableStream: params.disableStream,\n },\n rangeTransport\n );\n } else if (!params.data) {\n networkStream = createPDFNetworkStream({\n url: params.url,\n length: params.length,\n httpHeaders: params.httpHeaders,\n withCredentials: params.withCredentials,\n rangeChunkSize: params.rangeChunkSize,\n disableRange: params.disableRange,\n disableStream: params.disableStream,\n });\n }\n resolve(networkStream);\n });\n\n return Promise.all([workerIdPromise, networkStreamPromise]).then(\n function ([workerId, networkStream]) {\n if (task.destroyed) {\n throw new Error(\"Loading aborted\");\n }\n\n const messageHandler = new MessageHandler(\n docId,\n workerId,\n worker.port\n );\n messageHandler.postMessageTransfers = worker.postMessageTransfers;\n const transport = new WorkerTransport(\n messageHandler,\n task,\n networkStream,\n params\n );\n task._transport = transport;\n messageHandler.send(\"Ready\", null);\n }\n );\n })\n .catch(task._capability.reject);\n\n return task;\n}\n\n/**\n * Starts fetching of specified PDF document/data.\n * @param {PDFWorker} worker\n * @param {Object} source\n * @param {PDFDataRangeTransport} pdfDataRangeTransport\n * @param {string} docId Unique document id, used as MessageHandler id.\n * @returns {Promise} The promise, which is resolved when worker id of\n * MessageHandler is known.\n * @private\n */\nfunction _fetchDocument(worker, source, pdfDataRangeTransport, docId) {\n if (worker.destroyed) {\n return Promise.reject(new Error(\"Worker was destroyed\"));\n }\n\n if (pdfDataRangeTransport) {\n source.length = pdfDataRangeTransport.length;\n source.initialData = pdfDataRangeTransport.initialData;\n source.progressiveDone = pdfDataRangeTransport.progressiveDone;\n }\n return worker.messageHandler\n .sendWithPromise(\"GetDocRequest\", {\n docId,\n apiVersion:\n typeof PDFJSDev !== \"undefined\" && !PDFJSDev.test(\"TESTING\")\n ? PDFJSDev.eval(\"BUNDLE_VERSION\")\n : null,\n // Only send the required properties, and *not* the entire object.\n source: {\n data: source.data,\n url: source.url,\n password: source.password,\n disableAutoFetch: source.disableAutoFetch,\n rangeChunkSize: source.rangeChunkSize,\n length: source.length,\n },\n maxImageSize: source.maxImageSize,\n disableFontFace: source.disableFontFace,\n postMessageTransfers: worker.postMessageTransfers,\n docBaseUrl: source.docBaseUrl,\n ignoreErrors: source.ignoreErrors,\n isEvalSupported: source.isEvalSupported,\n fontExtraProperties: source.fontExtraProperties,\n })\n .then(function (workerId) {\n if (worker.destroyed) {\n throw new Error(\"Worker was destroyed\");\n }\n return workerId;\n });\n}\n\nconst PDFDocumentLoadingTask = (function PDFDocumentLoadingTaskClosure() {\n let nextDocumentId = 0;\n\n /**\n * The loading task controls the operations required to load a PDF document\n * (such as network requests) and provides a way to listen for completion,\n * after which individual pages can be rendered.\n */\n // eslint-disable-next-line no-shadow\n class PDFDocumentLoadingTask {\n constructor() {\n this._capability = createPromiseCapability();\n this._transport = null;\n this._worker = null;\n\n /**\n * Unique document loading task id -- used in MessageHandlers.\n * @type {string}\n */\n this.docId = \"d\" + nextDocumentId++;\n\n /**\n * Shows if loading task is destroyed.\n * @type {boolean}\n */\n this.destroyed = false;\n\n /**\n * Callback to request a password if wrong or no password was provided.\n * The callback receives two parameters: function that needs to be called\n * with new password and reason (see {PasswordResponses}).\n */\n this.onPassword = null;\n\n /**\n * Callback to be able to monitor the loading progress of the PDF file\n * (necessary to implement e.g. a loading bar). The callback receives\n * an {Object} with the properties: {number} loaded and {number} total.\n */\n this.onProgress = null;\n\n /**\n * Callback to when unsupported feature is used. The callback receives\n * an {UNSUPPORTED_FEATURES} argument.\n */\n this.onUnsupportedFeature = null;\n }\n\n /**\n * Promise for document loading task completion.\n * @type {Promise}\n */\n get promise() {\n return this._capability.promise;\n }\n\n /**\n * Aborts all network requests and destroys worker.\n * @returns {Promise} A promise that is resolved after destruction activity\n * is completed.\n */\n destroy() {\n this.destroyed = true;\n\n const transportDestroyed = !this._transport\n ? Promise.resolve()\n : this._transport.destroy();\n return transportDestroyed.then(() => {\n this._transport = null;\n if (this._worker) {\n this._worker.destroy();\n this._worker = null;\n }\n });\n }\n }\n return PDFDocumentLoadingTask;\n})();\n\n/**\n * Abstract class to support range requests file loading.\n * @param {number} length\n * @param {Uint8Array} initialData\n * @param {boolean} progressiveDone\n */\nclass PDFDataRangeTransport {\n constructor(length, initialData, progressiveDone = false) {\n this.length = length;\n this.initialData = initialData;\n this.progressiveDone = progressiveDone;\n\n this._rangeListeners = [];\n this._progressListeners = [];\n this._progressiveReadListeners = [];\n this._progressiveDoneListeners = [];\n this._readyCapability = createPromiseCapability();\n }\n\n addRangeListener(listener) {\n this._rangeListeners.push(listener);\n }\n\n addProgressListener(listener) {\n this._progressListeners.push(listener);\n }\n\n addProgressiveReadListener(listener) {\n this._progressiveReadListeners.push(listener);\n }\n\n addProgressiveDoneListener(listener) {\n this._progressiveDoneListeners.push(listener);\n }\n\n onDataRange(begin, chunk) {\n for (const listener of this._rangeListeners) {\n listener(begin, chunk);\n }\n }\n\n onDataProgress(loaded, total) {\n this._readyCapability.promise.then(() => {\n for (const listener of this._progressListeners) {\n listener(loaded, total);\n }\n });\n }\n\n onDataProgressiveRead(chunk) {\n this._readyCapability.promise.then(() => {\n for (const listener of this._progressiveReadListeners) {\n listener(chunk);\n }\n });\n }\n\n onDataProgressiveDone() {\n this._readyCapability.promise.then(() => {\n for (const listener of this._progressiveDoneListeners) {\n listener();\n }\n });\n }\n\n transportReady() {\n this._readyCapability.resolve();\n }\n\n requestDataRange(begin, end) {\n unreachable(\"Abstract method PDFDataRangeTransport.requestDataRange\");\n }\n\n abort() {}\n}\n\n/**\n * Proxy to a PDFDocument in the worker thread. Also, contains commonly used\n * properties that can be read synchronously.\n */\nclass PDFDocumentProxy {\n constructor(pdfInfo, transport) {\n this._pdfInfo = pdfInfo;\n this._transport = transport;\n }\n\n /**\n * @type {number} Total number of pages the PDF contains.\n */\n get numPages() {\n return this._pdfInfo.numPages;\n }\n\n /**\n * @type {string} A (not guaranteed to be) unique ID to identify a PDF.\n */\n get fingerprint() {\n return this._pdfInfo.fingerprint;\n }\n\n /**\n * @param {number} pageNumber - The page number to get. The first page is 1.\n * @returns {Promise} A promise that is resolved with a {@link PDFPageProxy}\n * object.\n */\n getPage(pageNumber) {\n return this._transport.getPage(pageNumber);\n }\n\n /**\n * @param {{num: number, gen: number}} ref - The page reference. Must have\n * the `num` and `gen` properties.\n * @returns {Promise} A promise that is resolved with the page index (starting\n * from zero) that is associated with the reference.\n */\n getPageIndex(ref) {\n return this._transport.getPageIndex(ref);\n }\n\n /**\n * @returns {Promise} A promise that is resolved with a lookup table for\n * mapping named destinations to reference numbers.\n *\n * This can be slow for large documents. Use `getDestination` instead.\n */\n getDestinations() {\n return this._transport.getDestinations();\n }\n\n /**\n * @param {string} id - The named destination to get.\n * @returns {Promise} A promise that is resolved with all information\n * of the given named destination.\n */\n getDestination(id) {\n return this._transport.getDestination(id);\n }\n\n /**\n * @returns {Promise} A promise that is resolved with an {Array} containing\n * the page labels that correspond to the page indexes, or `null` when\n * no page labels are present in the PDF file.\n */\n getPageLabels() {\n return this._transport.getPageLabels();\n }\n\n /**\n * @returns {Promise} A promise that is resolved with a {string} containing\n * the page layout name.\n */\n getPageLayout() {\n return this._transport.getPageLayout();\n }\n\n /**\n * @returns {Promise} A promise that is resolved with a {string} containing\n * the page mode name.\n */\n getPageMode() {\n return this._transport.getPageMode();\n }\n\n /**\n * @returns {Promise} A promise that is resolved with an {Object} containing\n * the viewer preferences, or `null` when no viewer preferences are present\n * in the PDF file.\n */\n getViewerPreferences() {\n return this._transport.getViewerPreferences();\n }\n\n /**\n * @returns {Promise} A promise that is resolved with an {Object} containing\n * the currently supported actions, or `null` when no OpenAction exists.\n */\n getOpenAction() {\n return this._transport.getOpenAction();\n }\n\n getOpenActionDestination() {\n deprecated(\"getOpenActionDestination, use getOpenAction instead.\");\n return this.getOpenAction().then(function (openAction) {\n return openAction && openAction.dest ? openAction.dest : null;\n });\n }\n\n /**\n * @returns {Promise} A promise that is resolved with a lookup table for\n * mapping named attachments to their content.\n */\n getAttachments() {\n return this._transport.getAttachments();\n }\n\n /**\n * @returns {Promise} A promise that is resolved with an {Array} of all the\n * JavaScript strings in the name tree, or `null` if no JavaScript exists.\n */\n getJavaScript() {\n return this._transport.getJavaScript();\n }\n\n /**\n * @returns {Promise} A promise that is resolved with an {Array} that is a\n * tree outline (if it has one) of the PDF. The tree is in the format of:\n * [\n * {\n * title: string,\n * bold: boolean,\n * italic: boolean,\n * color: rgb Uint8ClampedArray,\n * count: integer or undefined,\n * dest: dest obj,\n * url: string,\n * items: array of more items like this\n * },\n * ...\n * ]\n */\n getOutline() {\n return this._transport.getOutline();\n }\n\n /**\n * @returns {Promise} A promise that is resolved with an {Array} that contains\n * the permission flags for the PDF document, or `null` when\n * no permissions are present in the PDF file.\n */\n getPermissions() {\n return this._transport.getPermissions();\n }\n\n /**\n * @returns {Promise} A promise that is resolved with an {Object} that has\n * `info` and `metadata` properties. `info` is an {Object} filled with\n * anything available in the information dictionary and similarly\n * `metadata` is a {Metadata} object with information from the metadata\n * section of the PDF.\n */\n getMetadata() {\n return this._transport.getMetadata();\n }\n\n /**\n * @returns {Promise} A promise that is resolved with a {TypedArray} that has\n * the raw data from the PDF.\n */\n getData() {\n return this._transport.getData();\n }\n\n /**\n * @returns {Promise} A promise that is resolved when the document's data\n * is loaded. It is resolved with an {Object} that contains the `length`\n * property that indicates size of the PDF data in bytes.\n */\n getDownloadInfo() {\n return this._transport.downloadInfoCapability.promise;\n }\n\n /**\n * @returns {Promise} A promise this is resolved with current statistics about\n * document structures (see {@link PDFDocumentStats}).\n */\n getStats() {\n return this._transport.getStats();\n }\n\n /**\n * Cleans up resources allocated by the document, on both the main- and\n * worker-threads.\n *\n * NOTE: Do not, under any circumstances, call this method when rendering is\n * currently ongoing since that may lead to rendering errors.\n *\n * @returns {Promise} A promise that is resolved when clean-up has finished.\n */\n cleanup() {\n return this._transport.startCleanup();\n }\n\n /**\n * Destroys the current document instance and terminates the worker.\n */\n destroy() {\n return this.loadingTask.destroy();\n }\n\n /**\n * @type {Object} A subset of the current {DocumentInitParameters}, which are\n * either needed in the viewer and/or whose default values may be affected\n * by the `apiCompatibilityParams`.\n */\n get loadingParams() {\n return this._transport.loadingParams;\n }\n\n /**\n * @type {PDFDocumentLoadingTask} The loadingTask for the current document.\n */\n get loadingTask() {\n return this._transport.loadingTask;\n }\n}\n\n/**\n * Page getViewport parameters.\n *\n * @typedef {Object} GetViewportParameters\n * @property {number} scale - The desired scale of the viewport.\n * @property {number} [rotation] - The desired rotation, in degrees, of\n * the viewport. If omitted it defaults to the page rotation.\n * @property {number} [offsetX] - The horizontal, i.e. x-axis, offset.\n * The default value is `0`.\n * @property {number} [offsetY] - The vertical, i.e. y-axis, offset.\n * The default value is `0`.\n * @property {boolean} [dontFlip] - If true, the y-axis will not be\n * flipped. The default value is `false`.\n */\n\n/**\n * Page getTextContent parameters.\n *\n * @typedef {Object} getTextContentParameters\n * @property {boolean} normalizeWhitespace - replaces all occurrences of\n * whitespace with standard spaces (0x20). The default value is `false`.\n * @property {boolean} disableCombineTextItems - do not attempt to combine\n * same line {@link TextItem}'s. The default value is `false`.\n */\n\n/**\n * Page text content.\n *\n * @typedef {Object} TextContent\n * @property {array} items - array of {@link TextItem}\n * @property {Object} styles - {@link TextStyle} objects, indexed by font name.\n */\n\n/**\n * Page text content part.\n *\n * @typedef {Object} TextItem\n * @property {string} str - text content.\n * @property {string} dir - text direction: 'ttb', 'ltr' or 'rtl'.\n * @property {array} transform - transformation matrix.\n * @property {number} width - width in device space.\n * @property {number} height - height in device space.\n * @property {string} fontName - font name used by pdf.js for converted font.\n */\n\n/**\n * Text style.\n *\n * @typedef {Object} TextStyle\n * @property {number} ascent - font ascent.\n * @property {number} descent - font descent.\n * @property {boolean} vertical - text is in vertical mode.\n * @property {string} fontFamily - possible font family\n */\n\n/**\n * Page annotation parameters.\n *\n * @typedef {Object} GetAnnotationsParameters\n * @property {string} intent - Determines the annotations that will be fetched,\n * can be either 'display' (viewable annotations) or 'print'\n * (printable annotations).\n * If the parameter is omitted, all annotations are fetched.\n */\n\n/**\n * Page render parameters.\n *\n * @typedef {Object} RenderParameters\n * @property {Object} canvasContext - A 2D context of a DOM Canvas object.\n * @property {PageViewport} viewport - Rendering viewport obtained by\n * calling the `PDFPageProxy.getViewport` method.\n * @property {string} [intent] - Rendering intent, can be 'display' or 'print'\n * (default value is 'display').\n * @property {boolean} [enableWebGL] - Enables WebGL accelerated rendering\n * for some operations. The default value is `false`.\n * @property {boolean} [renderInteractiveForms] - Whether or not\n * interactive form elements are rendered in the display\n * layer. If so, we do not render them on canvas as well.\n * @property {Array} [transform] - Additional transform, applied\n * just before viewport transform.\n * @property {Object} [imageLayer] - An object that has beginLayout,\n * endLayout and appendImage functions.\n * @property {Object} [canvasFactory] - The factory that will be used\n * when creating canvases. The default value is\n * {DOMCanvasFactory}.\n * @property {Object} [background] - Background to use for the canvas.\n * Can use any valid canvas.fillStyle: A DOMString parsed as\n * CSS <color> value, a CanvasGradient object (a linear or\n * radial gradient) or a CanvasPattern object (a repetitive\n * image). The default value is 'rgb(255,255,255)'.\n */\n\n/**\n * PDF page operator list.\n *\n * @typedef {Object} PDFOperatorList\n * @property {Array} fnArray - Array containing the operator functions.\n * @property {Array} argsArray - Array containing the arguments of the\n * functions.\n */\n\n/**\n * Proxy to a PDFPage in the worker thread.\n * @alias PDFPageProxy\n */\nclass PDFPageProxy {\n constructor(pageIndex, pageInfo, transport, pdfBug = false) {\n this._pageIndex = pageIndex;\n this._pageInfo = pageInfo;\n this._transport = transport;\n this._stats = pdfBug ? new StatTimer() : null;\n this._pdfBug = pdfBug;\n this.commonObjs = transport.commonObjs;\n this.objs = new PDFObjects();\n\n this.cleanupAfterRender = false;\n this.pendingCleanup = false;\n this.intentStates = Object.create(null);\n this.destroyed = false;\n }\n\n /**\n * @type {number} Page number of the page. First page is 1.\n */\n get pageNumber() {\n return this._pageIndex + 1;\n }\n\n /**\n * @type {number} The number of degrees the page is rotated clockwise.\n */\n get rotate() {\n return this._pageInfo.rotate;\n }\n\n /**\n * @type {Object} The reference that points to this page. It has `num` and\n * `gen` properties.\n */\n get ref() {\n return this._pageInfo.ref;\n }\n\n /**\n * @type {number} The default size of units in 1/72nds of an inch.\n */\n get userUnit() {\n return this._pageInfo.userUnit;\n }\n\n /**\n * @type {Array} An array of the visible portion of the PDF page in user\n * space units [x1, y1, x2, y2].\n */\n get view() {\n return this._pageInfo.view;\n }\n\n /**\n * @param {GetViewportParameters} params - Viewport parameters.\n * @returns {PageViewport} Contains 'width' and 'height' properties\n * along with transforms required for rendering.\n */\n getViewport({\n scale,\n rotation = this.rotate,\n offsetX = 0,\n offsetY = 0,\n dontFlip = false,\n } = {}) {\n return new PageViewport({\n viewBox: this.view,\n scale,\n rotation,\n offsetX,\n offsetY,\n dontFlip,\n });\n }\n\n /**\n * @param {GetAnnotationsParameters} params - Annotation parameters.\n * @returns {Promise} A promise that is resolved with an {Array} of the\n * annotation objects.\n */\n getAnnotations({ intent = null } = {}) {\n if (!this.annotationsPromise || this.annotationsIntent !== intent) {\n this.annotationsPromise = this._transport.getAnnotations(\n this._pageIndex,\n intent\n );\n this.annotationsIntent = intent;\n }\n return this.annotationsPromise;\n }\n\n /**\n * Begins the process of rendering a page to the desired context.\n * @param {RenderParameters} params Page render parameters.\n * @returns {RenderTask} An object that contains the promise, which\n * is resolved when the page finishes rendering.\n */\n render({\n canvasContext,\n viewport,\n intent = \"display\",\n enableWebGL = false,\n renderInteractiveForms = false,\n transform = null,\n imageLayer = null,\n canvasFactory = null,\n background = null,\n }) {\n if (this._stats) {\n this._stats.time(\"Overall\");\n }\n\n const renderingIntent = intent === \"print\" ? \"print\" : \"display\";\n // If there was a pending destroy, cancel it so no cleanup happens during\n // this call to render.\n this.pendingCleanup = false;\n\n if (!this.intentStates[renderingIntent]) {\n this.intentStates[renderingIntent] = Object.create(null);\n }\n const intentState = this.intentStates[renderingIntent];\n\n // Ensure that a pending `streamReader` cancel timeout is always aborted.\n if (intentState.streamReaderCancelTimeout) {\n clearTimeout(intentState.streamReaderCancelTimeout);\n intentState.streamReaderCancelTimeout = null;\n }\n\n const canvasFactoryInstance = canvasFactory || new DOMCanvasFactory();\n const webGLContext = new WebGLContext({\n enable: enableWebGL,\n });\n\n // If there's no displayReadyCapability yet, then the operatorList\n // was never requested before. Make the request and create the promise.\n if (!intentState.displayReadyCapability) {\n intentState.displayReadyCapability = createPromiseCapability();\n intentState.operatorList = {\n fnArray: [],\n argsArray: [],\n lastChunk: false,\n };\n\n if (this._stats) {\n this._stats.time(\"Page Request\");\n }\n this._pumpOperatorList({\n pageIndex: this._pageIndex,\n intent: renderingIntent,\n renderInteractiveForms: renderInteractiveForms === true,\n });\n }\n\n const complete = error => {\n const i = intentState.renderTasks.indexOf(internalRenderTask);\n if (i >= 0) {\n intentState.renderTasks.splice(i, 1);\n }\n\n // Attempt to reduce memory usage during *printing*, by always running\n // cleanup once rendering has finished (regardless of cleanupAfterRender).\n if (this.cleanupAfterRender || renderingIntent === \"print\") {\n this.pendingCleanup = true;\n }\n this._tryCleanup();\n\n if (error) {\n internalRenderTask.capability.reject(error);\n\n this._abortOperatorList({\n intentState,\n reason: error,\n });\n } else {\n internalRenderTask.capability.resolve();\n }\n if (this._stats) {\n this._stats.timeEnd(\"Rendering\");\n this._stats.timeEnd(\"Overall\");\n }\n };\n\n const internalRenderTask = new InternalRenderTask({\n callback: complete,\n // Only include the required properties, and *not* the entire object.\n params: {\n canvasContext,\n viewport,\n transform,\n imageLayer,\n background,\n },\n objs: this.objs,\n commonObjs: this.commonObjs,\n operatorList: intentState.operatorList,\n pageIndex: this._pageIndex,\n canvasFactory: canvasFactoryInstance,\n webGLContext,\n useRequestAnimationFrame: renderingIntent !== \"print\",\n pdfBug: this._pdfBug,\n });\n\n if (!intentState.renderTasks) {\n intentState.renderTasks = [];\n }\n intentState.renderTasks.push(internalRenderTask);\n const renderTask = internalRenderTask.task;\n\n intentState.displayReadyCapability.promise\n .then(transparency => {\n if (this.pendingCleanup) {\n complete();\n return;\n }\n if (this._stats) {\n this._stats.time(\"Rendering\");\n }\n internalRenderTask.initializeGraphics(transparency);\n internalRenderTask.operatorListChanged();\n })\n .catch(complete);\n\n return renderTask;\n }\n\n /**\n * @returns {Promise} A promise resolved with an {@link PDFOperatorList}\n * object that represents page's operator list.\n */\n getOperatorList() {\n function operatorListChanged() {\n if (intentState.operatorList.lastChunk) {\n intentState.opListReadCapability.resolve(intentState.operatorList);\n\n const i = intentState.renderTasks.indexOf(opListTask);\n if (i >= 0) {\n intentState.renderTasks.splice(i, 1);\n }\n }\n }\n\n const renderingIntent = \"oplist\";\n if (!this.intentStates[renderingIntent]) {\n this.intentStates[renderingIntent] = Object.create(null);\n }\n const intentState = this.intentStates[renderingIntent];\n let opListTask;\n\n if (!intentState.opListReadCapability) {\n opListTask = {};\n opListTask.operatorListChanged = operatorListChanged;\n intentState.opListReadCapability = createPromiseCapability();\n intentState.renderTasks = [];\n intentState.renderTasks.push(opListTask);\n intentState.operatorList = {\n fnArray: [],\n argsArray: [],\n lastChunk: false,\n };\n\n if (this._stats) {\n this._stats.time(\"Page Request\");\n }\n this._pumpOperatorList({\n pageIndex: this._pageIndex,\n intent: renderingIntent,\n });\n }\n return intentState.opListReadCapability.promise;\n }\n\n /**\n * @param {getTextContentParameters} params - getTextContent parameters.\n * @returns {ReadableStream} ReadableStream to read textContent chunks.\n */\n streamTextContent({\n normalizeWhitespace = false,\n disableCombineTextItems = false,\n } = {}) {\n const TEXT_CONTENT_CHUNK_SIZE = 100;\n\n return this._transport.messageHandler.sendWithStream(\n \"GetTextContent\",\n {\n pageIndex: this._pageIndex,\n normalizeWhitespace: normalizeWhitespace === true,\n combineTextItems: disableCombineTextItems !== true,\n },\n {\n highWaterMark: TEXT_CONTENT_CHUNK_SIZE,\n size(textContent) {\n return textContent.items.length;\n },\n }\n );\n }\n\n /**\n * @param {getTextContentParameters} params - getTextContent parameters.\n * @returns {Promise} That is resolved a {@link TextContent}\n * object that represent the page text content.\n */\n getTextContent(params = {}) {\n const readableStream = this.streamTextContent(params);\n\n return new Promise(function (resolve, reject) {\n function pump() {\n reader.read().then(function ({ value, done }) {\n if (done) {\n resolve(textContent);\n return;\n }\n Object.assign(textContent.styles, value.styles);\n textContent.items.push(...value.items);\n pump();\n }, reject);\n }\n\n const reader = readableStream.getReader();\n const textContent = {\n items: [],\n styles: Object.create(null),\n };\n pump();\n });\n }\n\n /**\n * Destroys the page object.\n * @private\n */\n _destroy() {\n this.destroyed = true;\n this._transport.pageCache[this._pageIndex] = null;\n\n const waitOn = [];\n Object.keys(this.intentStates).forEach(intent => {\n const intentState = this.intentStates[intent];\n this._abortOperatorList({\n intentState,\n reason: new Error(\"Page was destroyed.\"),\n force: true,\n });\n\n if (intent === \"oplist\") {\n // Avoid errors below, since the renderTasks are just stubs.\n return;\n }\n intentState.renderTasks.forEach(function (renderTask) {\n const renderCompleted = renderTask.capability.promise.catch(\n function () {}\n ); // ignoring failures\n waitOn.push(renderCompleted);\n renderTask.cancel();\n });\n });\n this.objs.clear();\n this.annotationsPromise = null;\n this.pendingCleanup = false;\n return Promise.all(waitOn);\n }\n\n /**\n * Cleans up resources allocated by the page.\n * @param {boolean} [resetStats] - Reset page stats, if enabled.\n * The default value is `false`.\n * @returns {boolean} Indicating if clean-up was successfully run.\n */\n cleanup(resetStats = false) {\n this.pendingCleanup = true;\n return this._tryCleanup(resetStats);\n }\n\n /**\n * Attempts to clean up if rendering is in a state where that's possible.\n * @private\n */\n _tryCleanup(resetStats = false) {\n if (\n !this.pendingCleanup ||\n Object.keys(this.intentStates).some(intent => {\n const intentState = this.intentStates[intent];\n return (\n intentState.renderTasks.length !== 0 ||\n !intentState.operatorList.lastChunk\n );\n })\n ) {\n return false;\n }\n\n Object.keys(this.intentStates).forEach(intent => {\n delete this.intentStates[intent];\n });\n this.objs.clear();\n this.annotationsPromise = null;\n if (resetStats && this._stats) {\n this._stats = new StatTimer();\n }\n this.pendingCleanup = false;\n return true;\n }\n\n /**\n * @private\n */\n _startRenderPage(transparency, intent) {\n const intentState = this.intentStates[intent];\n if (!intentState) {\n return; // Rendering was cancelled.\n }\n if (this._stats) {\n this._stats.timeEnd(\"Page Request\");\n }\n // TODO Refactor RenderPageRequest to separate rendering\n // and operator list logic\n if (intentState.displayReadyCapability) {\n intentState.displayReadyCapability.resolve(transparency);\n }\n }\n\n /**\n * @private\n */\n _renderPageChunk(operatorListChunk, intentState) {\n // Add the new chunk to the current operator list.\n for (let i = 0, ii = operatorListChunk.length; i < ii; i++) {\n intentState.operatorList.fnArray.push(operatorListChunk.fnArray[i]);\n intentState.operatorList.argsArray.push(operatorListChunk.argsArray[i]);\n }\n intentState.operatorList.lastChunk = operatorListChunk.lastChunk;\n\n // Notify all the rendering tasks there are more operators to be consumed.\n for (let i = 0; i < intentState.renderTasks.length; i++) {\n intentState.renderTasks[i].operatorListChanged();\n }\n\n if (operatorListChunk.lastChunk) {\n this._tryCleanup();\n }\n }\n\n /**\n * @private\n */\n _pumpOperatorList(args) {\n assert(\n args.intent,\n 'PDFPageProxy._pumpOperatorList: Expected \"intent\" argument.'\n );\n\n const readableStream = this._transport.messageHandler.sendWithStream(\n \"GetOperatorList\",\n args\n );\n const reader = readableStream.getReader();\n\n const intentState = this.intentStates[args.intent];\n intentState.streamReader = reader;\n\n const pump = () => {\n reader.read().then(\n ({ value, done }) => {\n if (done) {\n intentState.streamReader = null;\n return;\n }\n if (this._transport.destroyed) {\n return; // Ignore any pending requests if the worker was terminated.\n }\n this._renderPageChunk(value, intentState);\n pump();\n },\n reason => {\n intentState.streamReader = null;\n\n if (this._transport.destroyed) {\n return; // Ignore any pending requests if the worker was terminated.\n }\n if (intentState.operatorList) {\n // Mark operator list as complete.\n intentState.operatorList.lastChunk = true;\n\n for (let i = 0; i < intentState.renderTasks.length; i++) {\n intentState.renderTasks[i].operatorListChanged();\n }\n this._tryCleanup();\n }\n\n if (intentState.displayReadyCapability) {\n intentState.displayReadyCapability.reject(reason);\n } else if (intentState.opListReadCapability) {\n intentState.opListReadCapability.reject(reason);\n } else {\n throw reason;\n }\n }\n );\n };\n pump();\n }\n\n /**\n * @private\n */\n _abortOperatorList({ intentState, reason, force = false }) {\n assert(\n reason instanceof Error ||\n (typeof reason === \"object\" && reason !== null),\n 'PDFPageProxy._abortOperatorList: Expected \"reason\" argument.'\n );\n\n if (!intentState.streamReader) {\n return;\n }\n if (!force) {\n // Ensure that an Error occurring in *only* one `InternalRenderTask`, e.g.\n // multiple render() calls on the same canvas, won't break all rendering.\n if (intentState.renderTasks.length !== 0) {\n return;\n }\n // Don't immediately abort parsing on the worker-thread when rendering is\n // cancelled, since that will unnecessarily delay re-rendering when (for\n // partially parsed pages) e.g. zooming/rotation occurs in the viewer.\n if (reason instanceof RenderingCancelledException) {\n intentState.streamReaderCancelTimeout = setTimeout(() => {\n this._abortOperatorList({ intentState, reason, force: true });\n intentState.streamReaderCancelTimeout = null;\n }, RENDERING_CANCELLED_TIMEOUT);\n return;\n }\n }\n intentState.streamReader.cancel(\n new AbortException(reason && reason.message)\n );\n intentState.streamReader = null;\n\n if (this._transport.destroyed) {\n return; // Ignore any pending requests if the worker was terminated.\n }\n // Remove the current `intentState`, since a cancelled `getOperatorList`\n // call on the worker-thread cannot be re-started...\n Object.keys(this.intentStates).some(intent => {\n if (this.intentStates[intent] === intentState) {\n delete this.intentStates[intent];\n return true;\n }\n return false;\n });\n // ... and force clean-up to ensure that any old state is always removed.\n this.cleanup();\n }\n\n /**\n * @type {Object} Returns page stats, if enabled; returns `null` otherwise.\n */\n get stats() {\n return this._stats;\n }\n}\n\nclass LoopbackPort {\n constructor(defer = true) {\n this._listeners = [];\n this._defer = defer;\n this._deferred = Promise.resolve(undefined);\n }\n\n postMessage(obj, transfers) {\n function cloneValue(value) {\n // Trying to perform a structured clone close to the spec, including\n // transfers.\n if (typeof value !== \"object\" || value === null) {\n return value;\n }\n if (cloned.has(value)) {\n // already cloned the object\n return cloned.get(value);\n }\n let buffer, result;\n if ((buffer = value.buffer) && isArrayBuffer(buffer)) {\n // We found object with ArrayBuffer (typed array).\n const transferable = transfers && transfers.includes(buffer);\n if (transferable) {\n result = new value.constructor(\n buffer,\n value.byteOffset,\n value.byteLength\n );\n } else {\n result = new value.constructor(value);\n }\n cloned.set(value, result);\n return result;\n }\n result = Array.isArray(value) ? [] : {};\n cloned.set(value, result); // adding to cache now for cyclic references\n // Cloning all value and object properties, however ignoring properties\n // defined via getter.\n for (const i in value) {\n let desc,\n p = value;\n while (!(desc = Object.getOwnPropertyDescriptor(p, i))) {\n p = Object.getPrototypeOf(p);\n }\n if (typeof desc.value === \"undefined\") {\n continue;\n }\n if (typeof desc.value === \"function\") {\n if (value.hasOwnProperty && value.hasOwnProperty(i)) {\n throw new Error(\n `LoopbackPort.postMessage - cannot clone: ${value[i]}`\n );\n }\n continue;\n }\n result[i] = cloneValue(desc.value);\n }\n return result;\n }\n\n if (!this._defer) {\n this._listeners.forEach(listener => {\n listener.call(this, { data: obj });\n });\n return;\n }\n\n const cloned = new WeakMap();\n const e = { data: cloneValue(obj) };\n this._deferred.then(() => {\n this._listeners.forEach(listener => {\n listener.call(this, e);\n });\n });\n }\n\n addEventListener(name, listener) {\n this._listeners.push(listener);\n }\n\n removeEventListener(name, listener) {\n const i = this._listeners.indexOf(listener);\n this._listeners.splice(i, 1);\n }\n\n terminate() {\n this._listeners.length = 0;\n }\n}\n\n/**\n * @typedef {Object} PDFWorkerParameters\n * @property {string} [name] - The name of the worker.\n * @property {Object} [port] - The `workerPort`.\n * @property {number} [verbosity] - Controls the logging level; the\n * constants from {VerbosityLevel} should be used.\n */\n\nconst PDFWorker = (function PDFWorkerClosure() {\n const pdfWorkerPorts = new WeakMap();\n let isWorkerDisabled = false;\n let fallbackWorkerSrc;\n let nextFakeWorkerId = 0;\n let fakeWorkerCapability;\n\n if (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"GENERIC\")) {\n // eslint-disable-next-line no-undef\n if (isNodeJS && typeof __non_webpack_require__ === \"function\") {\n // Workers aren't supported in Node.js, force-disabling them there.\n isWorkerDisabled = true;\n\n if (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"LIB\")) {\n fallbackWorkerSrc = \"../pdf.worker.js\";\n } else {\n fallbackWorkerSrc = \"./pdf.worker.js\";\n }\n } else if (typeof document === \"object\" && \"currentScript\" in document) {\n const pdfjsFilePath =\n document.currentScript && document.currentScript.src;\n if (pdfjsFilePath) {\n fallbackWorkerSrc = pdfjsFilePath.replace(\n /(\\.(?:min\\.)?js)(\\?.*)?$/i,\n \".worker$1$2\"\n );\n }\n }\n }\n\n function getWorkerSrc() {\n if (GlobalWorkerOptions.workerSrc) {\n return GlobalWorkerOptions.workerSrc;\n }\n if (typeof fallbackWorkerSrc !== \"undefined\") {\n if (!isNodeJS) {\n deprecated('No \"GlobalWorkerOptions.workerSrc\" specified.');\n }\n return fallbackWorkerSrc;\n }\n throw new Error('No \"GlobalWorkerOptions.workerSrc\" specified.');\n }\n\n function getMainThreadWorkerMessageHandler() {\n let mainWorkerMessageHandler;\n try {\n mainWorkerMessageHandler =\n globalThis.pdfjsWorker && globalThis.pdfjsWorker.WorkerMessageHandler;\n } catch (ex) {\n /* Ignore errors. */\n }\n return mainWorkerMessageHandler || null;\n }\n\n // Loads worker code into main thread.\n function setupFakeWorkerGlobal() {\n if (fakeWorkerCapability) {\n return fakeWorkerCapability.promise;\n }\n fakeWorkerCapability = createPromiseCapability();\n\n const loader = async function () {\n const mainWorkerMessageHandler = getMainThreadWorkerMessageHandler();\n\n if (mainWorkerMessageHandler) {\n // The worker was already loaded using e.g. a `<script>` tag.\n return mainWorkerMessageHandler;\n }\n if (typeof PDFJSDev === \"undefined\" || !PDFJSDev.test(\"PRODUCTION\")) {\n if (typeof SystemJS !== \"object\") {\n // Manually load SystemJS, since it's only necessary for fake workers.\n await loadScript(\"../node_modules/systemjs/dist/system.js\");\n await loadScript(\"../systemjs.config.js\");\n }\n const worker = await SystemJS.import(\"pdfjs/core/worker.js\");\n return worker.WorkerMessageHandler;\n }\n if (\n PDFJSDev.test(\"GENERIC\") &&\n isNodeJS &&\n // eslint-disable-next-line no-undef\n typeof __non_webpack_require__ === \"function\"\n ) {\n // Since bundlers, such as Webpack, cannot be told to leave `require`\n // statements alone we are thus forced to jump through hoops in order\n // to prevent `Critical dependency: ...` warnings in third-party\n // deployments of the built `pdf.js`/`pdf.worker.js` files; see\n // https://github.com/webpack/webpack/issues/8826\n //\n // The following hack is based on the assumption that code running in\n // Node.js won't ever be affected by e.g. Content Security Policies that\n // prevent the use of `eval`. If that ever occurs, we should revert this\n // to a normal `__non_webpack_require__` statement and simply document\n // the Webpack warnings instead (telling users to ignore them).\n //\n // eslint-disable-next-line no-eval\n const worker = eval(\"require\")(getWorkerSrc());\n return worker.WorkerMessageHandler;\n }\n await loadScript(getWorkerSrc());\n return window.pdfjsWorker.WorkerMessageHandler;\n };\n loader().then(fakeWorkerCapability.resolve, fakeWorkerCapability.reject);\n\n return fakeWorkerCapability.promise;\n }\n\n function createCDNWrapper(url) {\n // We will rely on blob URL's property to specify origin.\n // We want this function to fail in case if createObjectURL or Blob do not\n // exist or fail for some reason -- our Worker creation will fail anyway.\n const wrapper = \"importScripts('\" + url + \"');\";\n return URL.createObjectURL(new Blob([wrapper]));\n }\n\n /**\n * PDF.js web worker abstraction, which controls the instantiation of PDF\n * documents. Message handlers are used to pass information from the main\n * thread to the worker thread and vice versa. If the creation of a web\n * worker is not possible, a \"fake\" worker will be used instead.\n */\n // eslint-disable-next-line no-shadow\n class PDFWorker {\n /**\n * @param {PDFWorkerParameters} params - Worker initialization parameters.\n */\n constructor({\n name = null,\n port = null,\n verbosity = getVerbosityLevel(),\n } = {}) {\n if (port && pdfWorkerPorts.has(port)) {\n throw new Error(\"Cannot use more than one PDFWorker per port\");\n }\n\n this.name = name;\n this.destroyed = false;\n this.postMessageTransfers = true;\n this.verbosity = verbosity;\n\n this._readyCapability = createPromiseCapability();\n this._port = null;\n this._webWorker = null;\n this._messageHandler = null;\n\n if (port) {\n pdfWorkerPorts.set(port, this);\n this._initializeFromPort(port);\n return;\n }\n this._initialize();\n }\n\n get promise() {\n return this._readyCapability.promise;\n }\n\n get port() {\n return this._port;\n }\n\n get messageHandler() {\n return this._messageHandler;\n }\n\n _initializeFromPort(port) {\n this._port = port;\n this._messageHandler = new MessageHandler(\"main\", \"worker\", port);\n this._messageHandler.on(\"ready\", function () {\n // Ignoring 'ready' event -- MessageHandler shall be already initialized\n // and ready to accept the messages.\n });\n this._readyCapability.resolve();\n }\n\n _initialize() {\n // If worker support isn't disabled explicit and the browser has worker\n // support, create a new web worker and test if it/the browser fulfills\n // all requirements to run parts of pdf.js in a web worker.\n // Right now, the requirement is, that an Uint8Array is still an\n // Uint8Array as it arrives on the worker. (Chrome added this with v.15.)\n if (\n typeof Worker !== \"undefined\" &&\n !isWorkerDisabled &&\n !getMainThreadWorkerMessageHandler()\n ) {\n let workerSrc = getWorkerSrc();\n\n try {\n // Wraps workerSrc path into blob URL, if the former does not belong\n // to the same origin.\n if (\n typeof PDFJSDev !== \"undefined\" &&\n PDFJSDev.test(\"GENERIC\") &&\n !isSameOrigin(window.location.href, workerSrc)\n ) {\n workerSrc = createCDNWrapper(\n new URL(workerSrc, window.location).href\n );\n }\n\n // Some versions of FF can't create a worker on localhost, see:\n // https://bugzilla.mozilla.org/show_bug.cgi?id=683280\n const worker = new Worker(workerSrc);\n const messageHandler = new MessageHandler(\"main\", \"worker\", worker);\n const terminateEarly = () => {\n worker.removeEventListener(\"error\", onWorkerError);\n messageHandler.destroy();\n worker.terminate();\n if (this.destroyed) {\n this._readyCapability.reject(new Error(\"Worker was destroyed\"));\n } else {\n // Fall back to fake worker if the termination is caused by an\n // error (e.g. NetworkError / SecurityError).\n this._setupFakeWorker();\n }\n };\n\n const onWorkerError = () => {\n if (!this._webWorker) {\n // Worker failed to initialize due to an error. Clean up and fall\n // back to the fake worker.\n terminateEarly();\n }\n };\n worker.addEventListener(\"error\", onWorkerError);\n\n messageHandler.on(\"test\", data => {\n worker.removeEventListener(\"error\", onWorkerError);\n if (this.destroyed) {\n terminateEarly();\n return; // worker was destroyed\n }\n if (data) {\n // supportTypedArray\n this._messageHandler = messageHandler;\n this._port = worker;\n this._webWorker = worker;\n if (!data.supportTransfers) {\n this.postMessageTransfers = false;\n }\n this._readyCapability.resolve();\n // Send global setting, e.g. verbosity level.\n messageHandler.send(\"configure\", {\n verbosity: this.verbosity,\n });\n } else {\n this._setupFakeWorker();\n messageHandler.destroy();\n worker.terminate();\n }\n });\n\n messageHandler.on(\"ready\", data => {\n worker.removeEventListener(\"error\", onWorkerError);\n if (this.destroyed) {\n terminateEarly();\n return; // worker was destroyed\n }\n try {\n sendTest();\n } catch (e) {\n // We need fallback to a faked worker.\n this._setupFakeWorker();\n }\n });\n\n const sendTest = () => {\n const testObj = new Uint8Array([\n this.postMessageTransfers ? 255 : 0,\n ]);\n // Some versions of Opera throw a DATA_CLONE_ERR on serializing the\n // typed array. Also, checking if we can use transfers.\n try {\n messageHandler.send(\"test\", testObj, [testObj.buffer]);\n } catch (ex) {\n warn(\"Cannot use postMessage transfers.\");\n testObj[0] = 0;\n messageHandler.send(\"test\", testObj);\n }\n };\n\n // It might take time for worker to initialize (especially when AMD\n // loader is used). We will try to send test immediately, and then\n // when 'ready' message will arrive. The worker shall process only\n // first received 'test'.\n sendTest();\n return;\n } catch (e) {\n info(\"The worker has been disabled.\");\n }\n }\n // Either workers are disabled, not supported or have thrown an exception.\n // Thus, we fallback to a faked worker.\n this._setupFakeWorker();\n }\n\n _setupFakeWorker() {\n if (!isWorkerDisabled) {\n warn(\"Setting up fake worker.\");\n isWorkerDisabled = true;\n }\n\n setupFakeWorkerGlobal()\n .then(WorkerMessageHandler => {\n if (this.destroyed) {\n this._readyCapability.reject(new Error(\"Worker was destroyed\"));\n return;\n }\n const port = new LoopbackPort();\n this._port = port;\n\n // All fake workers use the same port, making id unique.\n const id = \"fake\" + nextFakeWorkerId++;\n\n // If the main thread is our worker, setup the handling for the\n // messages -- the main thread sends to it self.\n const workerHandler = new MessageHandler(id + \"_worker\", id, port);\n WorkerMessageHandler.setup(workerHandler, port);\n\n const messageHandler = new MessageHandler(id, id + \"_worker\", port);\n this._messageHandler = messageHandler;\n this._readyCapability.resolve();\n // Send global setting, e.g. verbosity level.\n messageHandler.send(\"configure\", {\n verbosity: this.verbosity,\n });\n })\n .catch(reason => {\n this._readyCapability.reject(\n new Error(`Setting up fake worker failed: \"${reason.message}\".`)\n );\n });\n }\n\n /**\n * Destroys the worker instance.\n */\n destroy() {\n this.destroyed = true;\n if (this._webWorker) {\n // We need to terminate only web worker created resource.\n this._webWorker.terminate();\n this._webWorker = null;\n }\n pdfWorkerPorts.delete(this._port);\n this._port = null;\n if (this._messageHandler) {\n this._messageHandler.destroy();\n this._messageHandler = null;\n }\n }\n\n /**\n * @param {PDFWorkerParameters} params - The worker initialization\n * parameters.\n */\n static fromPort(params) {\n if (!params || !params.port) {\n throw new Error(\"PDFWorker.fromPort - invalid method signature.\");\n }\n if (pdfWorkerPorts.has(params.port)) {\n return pdfWorkerPorts.get(params.port);\n }\n return new PDFWorker(params);\n }\n\n static getWorkerSrc() {\n return getWorkerSrc();\n }\n }\n return PDFWorker;\n})();\n\n/**\n * For internal use only.\n * @ignore\n */\nclass WorkerTransport {\n constructor(messageHandler, loadingTask, networkStream, params) {\n this.messageHandler = messageHandler;\n this.loadingTask = loadingTask;\n this.commonObjs = new PDFObjects();\n this.fontLoader = new FontLoader({\n docId: loadingTask.docId,\n onUnsupportedFeature: this._onUnsupportedFeature.bind(this),\n });\n this._params = params;\n this.CMapReaderFactory = new params.CMapReaderFactory({\n baseUrl: params.cMapUrl,\n isCompressed: params.cMapPacked,\n });\n\n this.destroyed = false;\n this.destroyCapability = null;\n this._passwordCapability = null;\n\n this._networkStream = networkStream;\n this._fullReader = null;\n this._lastProgress = null;\n\n this.pageCache = [];\n this.pagePromises = [];\n this.downloadInfoCapability = createPromiseCapability();\n\n this.setupMessageHandler();\n }\n\n destroy() {\n if (this.destroyCapability) {\n return this.destroyCapability.promise;\n }\n\n this.destroyed = true;\n this.destroyCapability = createPromiseCapability();\n\n if (this._passwordCapability) {\n this._passwordCapability.reject(\n new Error(\"Worker was destroyed during onPassword callback\")\n );\n }\n\n const waitOn = [];\n // We need to wait for all renderings to be completed, e.g.\n // timeout/rAF can take a long time.\n this.pageCache.forEach(function (page) {\n if (page) {\n waitOn.push(page._destroy());\n }\n });\n this.pageCache.length = 0;\n this.pagePromises.length = 0;\n // We also need to wait for the worker to finish its long running tasks.\n const terminated = this.messageHandler.sendWithPromise(\"Terminate\", null);\n waitOn.push(terminated);\n Promise.all(waitOn).then(() => {\n this.fontLoader.clear();\n if (this._networkStream) {\n this._networkStream.cancelAllRequests(\n new AbortException(\"Worker was terminated.\")\n );\n }\n\n if (this.messageHandler) {\n this.messageHandler.destroy();\n this.messageHandler = null;\n }\n this.destroyCapability.resolve();\n }, this.destroyCapability.reject);\n return this.destroyCapability.promise;\n }\n\n setupMessageHandler() {\n const { messageHandler, loadingTask } = this;\n\n messageHandler.on(\"GetReader\", (data, sink) => {\n assert(\n this._networkStream,\n \"GetReader - no `IPDFStream` instance available.\"\n );\n this._fullReader = this._networkStream.getFullReader();\n this._fullReader.onProgress = evt => {\n this._lastProgress = {\n loaded: evt.loaded,\n total: evt.total,\n };\n };\n sink.onPull = () => {\n this._fullReader\n .read()\n .then(function ({ value, done }) {\n if (done) {\n sink.close();\n return;\n }\n assert(\n isArrayBuffer(value),\n \"GetReader - expected an ArrayBuffer.\"\n );\n // Enqueue data chunk into sink, and transfer it\n // to other side as `Transferable` object.\n sink.enqueue(new Uint8Array(value), 1, [value]);\n })\n .catch(reason => {\n sink.error(reason);\n });\n };\n\n sink.onCancel = reason => {\n this._fullReader.cancel(reason);\n };\n });\n\n messageHandler.on(\"ReaderHeadersReady\", data => {\n const headersCapability = createPromiseCapability();\n const fullReader = this._fullReader;\n fullReader.headersReady.then(() => {\n // If stream or range are disabled, it's our only way to report\n // loading progress.\n if (!fullReader.isStreamingSupported || !fullReader.isRangeSupported) {\n if (this._lastProgress && loadingTask.onProgress) {\n loadingTask.onProgress(this._lastProgress);\n }\n fullReader.onProgress = evt => {\n if (loadingTask.onProgress) {\n loadingTask.onProgress({\n loaded: evt.loaded,\n total: evt.total,\n });\n }\n };\n }\n\n headersCapability.resolve({\n isStreamingSupported: fullReader.isStreamingSupported,\n isRangeSupported: fullReader.isRangeSupported,\n contentLength: fullReader.contentLength,\n });\n }, headersCapability.reject);\n\n return headersCapability.promise;\n });\n\n messageHandler.on(\"GetRangeReader\", (data, sink) => {\n assert(\n this._networkStream,\n \"GetRangeReader - no `IPDFStream` instance available.\"\n );\n const rangeReader = this._networkStream.getRangeReader(\n data.begin,\n data.end\n );\n\n // When streaming is enabled, it's possible that the data requested here\n // has already been fetched via the `_fullRequestReader` implementation.\n // However, given that the PDF data is loaded asynchronously on the\n // main-thread and then sent via `postMessage` to the worker-thread,\n // it may not have been available during parsing (hence the attempt to\n // use range requests here).\n //\n // To avoid wasting time and resources here, we'll thus *not* dispatch\n // range requests if the data was already loaded but has not been sent to\n // the worker-thread yet (which will happen via the `_fullRequestReader`).\n if (!rangeReader) {\n sink.close();\n return;\n }\n\n sink.onPull = () => {\n rangeReader\n .read()\n .then(function ({ value, done }) {\n if (done) {\n sink.close();\n return;\n }\n assert(\n isArrayBuffer(value),\n \"GetRangeReader - expected an ArrayBuffer.\"\n );\n sink.enqueue(new Uint8Array(value), 1, [value]);\n })\n .catch(reason => {\n sink.error(reason);\n });\n };\n\n sink.onCancel = reason => {\n rangeReader.cancel(reason);\n };\n });\n\n messageHandler.on(\"GetDoc\", ({ pdfInfo }) => {\n this._numPages = pdfInfo.numPages;\n loadingTask._capability.resolve(new PDFDocumentProxy(pdfInfo, this));\n });\n\n messageHandler.on(\"DocException\", function (ex) {\n let reason;\n switch (ex.name) {\n case \"PasswordException\":\n reason = new PasswordException(ex.message, ex.code);\n break;\n case \"InvalidPDFException\":\n reason = new InvalidPDFException(ex.message);\n break;\n case \"MissingPDFException\":\n reason = new MissingPDFException(ex.message);\n break;\n case \"UnexpectedResponseException\":\n reason = new UnexpectedResponseException(ex.message, ex.status);\n break;\n case \"UnknownErrorException\":\n reason = new UnknownErrorException(ex.message, ex.details);\n break;\n }\n if (\n typeof PDFJSDev === \"undefined\" ||\n PDFJSDev.test(\"!PRODUCTION || TESTING\")\n ) {\n assert(reason instanceof Error, \"DocException: expected an Error.\");\n }\n loadingTask._capability.reject(reason);\n });\n\n messageHandler.on(\"PasswordRequest\", exception => {\n this._passwordCapability = createPromiseCapability();\n\n if (loadingTask.onPassword) {\n const updatePassword = password => {\n this._passwordCapability.resolve({\n password,\n });\n };\n try {\n loadingTask.onPassword(updatePassword, exception.code);\n } catch (ex) {\n this._passwordCapability.reject(ex);\n }\n } else {\n this._passwordCapability.reject(\n new PasswordException(exception.message, exception.code)\n );\n }\n return this._passwordCapability.promise;\n });\n\n messageHandler.on(\"DataLoaded\", data => {\n // For consistency: Ensure that progress is always reported when the\n // entire PDF file has been loaded, regardless of how it was fetched.\n if (loadingTask.onProgress) {\n loadingTask.onProgress({\n loaded: data.length,\n total: data.length,\n });\n }\n this.downloadInfoCapability.resolve(data);\n });\n\n messageHandler.on(\"StartRenderPage\", data => {\n if (this.destroyed) {\n return; // Ignore any pending requests if the worker was terminated.\n }\n\n const page = this.pageCache[data.pageIndex];\n page._startRenderPage(data.transparency, data.intent);\n });\n\n messageHandler.on(\"commonobj\", data => {\n if (this.destroyed) {\n return; // Ignore any pending requests if the worker was terminated.\n }\n\n const [id, type, exportedData] = data;\n if (this.commonObjs.has(id)) {\n return;\n }\n\n switch (type) {\n case \"Font\":\n const params = this._params;\n\n if (\"error\" in exportedData) {\n const exportedError = exportedData.error;\n warn(`Error during font loading: ${exportedError}`);\n this.commonObjs.resolve(id, exportedError);\n break;\n }\n\n let fontRegistry = null;\n if (\n params.pdfBug &&\n globalThis.FontInspector &&\n globalThis.FontInspector.enabled\n ) {\n fontRegistry = {\n registerFont(font, url) {\n globalThis.FontInspector.fontAdded(font, url);\n },\n };\n }\n const font = new FontFaceObject(exportedData, {\n isEvalSupported: params.isEvalSupported,\n disableFontFace: params.disableFontFace,\n ignoreErrors: params.ignoreErrors,\n onUnsupportedFeature: this._onUnsupportedFeature.bind(this),\n fontRegistry,\n });\n\n this.fontLoader\n .bind(font)\n .catch(reason => {\n return messageHandler.sendWithPromise(\"FontFallback\", { id });\n })\n .finally(() => {\n if (!params.fontExtraProperties && font.data) {\n // Immediately release the `font.data` property once the font\n // has been attached to the DOM, since it's no longer needed,\n // rather than waiting for a `PDFDocumentProxy.cleanup` call.\n // Since `font.data` could be very large, e.g. in some cases\n // multiple megabytes, this will help reduce memory usage.\n font.data = null;\n }\n this.commonObjs.resolve(id, font);\n });\n break;\n case \"FontPath\":\n case \"FontType3Res\":\n case \"Image\":\n this.commonObjs.resolve(id, exportedData);\n break;\n default:\n throw new Error(`Got unknown common object type ${type}`);\n }\n });\n\n messageHandler.on(\"obj\", data => {\n if (this.destroyed) {\n // Ignore any pending requests if the worker was terminated.\n return undefined;\n }\n\n const [id, pageIndex, type, imageData] = data;\n const pageProxy = this.pageCache[pageIndex];\n if (pageProxy.objs.has(id)) {\n return undefined;\n }\n\n switch (type) {\n case \"Image\":\n pageProxy.objs.resolve(id, imageData);\n\n // Heuristic that will allow us not to store large data.\n const MAX_IMAGE_SIZE_TO_STORE = 8000000;\n if (\n imageData &&\n \"data\" in imageData &&\n imageData.data.length > MAX_IMAGE_SIZE_TO_STORE\n ) {\n pageProxy.cleanupAfterRender = true;\n }\n break;\n default:\n throw new Error(`Got unknown object type ${type}`);\n }\n return undefined;\n });\n\n messageHandler.on(\"DocProgress\", data => {\n if (this.destroyed) {\n return; // Ignore any pending requests if the worker was terminated.\n }\n\n if (loadingTask.onProgress) {\n loadingTask.onProgress({\n loaded: data.loaded,\n total: data.total,\n });\n }\n });\n\n messageHandler.on(\n \"UnsupportedFeature\",\n this._onUnsupportedFeature.bind(this)\n );\n\n messageHandler.on(\"FetchBuiltInCMap\", (data, sink) => {\n if (this.destroyed) {\n sink.error(new Error(\"Worker was destroyed\"));\n return;\n }\n let fetched = false;\n\n sink.onPull = () => {\n if (fetched) {\n sink.close();\n return;\n }\n fetched = true;\n\n this.CMapReaderFactory.fetch(data)\n .then(function (builtInCMap) {\n sink.enqueue(builtInCMap, 1, [builtInCMap.cMapData.buffer]);\n })\n .catch(function (reason) {\n sink.error(reason);\n });\n };\n });\n }\n\n _onUnsupportedFeature({ featureId }) {\n if (this.destroyed) {\n return; // Ignore any pending requests if the worker was terminated.\n }\n if (this.loadingTask.onUnsupportedFeature) {\n this.loadingTask.onUnsupportedFeature(featureId);\n }\n }\n\n getData() {\n return this.messageHandler.sendWithPromise(\"GetData\", null);\n }\n\n getPage(pageNumber) {\n if (\n !Number.isInteger(pageNumber) ||\n pageNumber <= 0 ||\n pageNumber > this._numPages\n ) {\n return Promise.reject(new Error(\"Invalid page request\"));\n }\n\n const pageIndex = pageNumber - 1;\n if (pageIndex in this.pagePromises) {\n return this.pagePromises[pageIndex];\n }\n const promise = this.messageHandler\n .sendWithPromise(\"GetPage\", {\n pageIndex,\n })\n .then(pageInfo => {\n if (this.destroyed) {\n throw new Error(\"Transport destroyed\");\n }\n const page = new PDFPageProxy(\n pageIndex,\n pageInfo,\n this,\n this._params.pdfBug\n );\n this.pageCache[pageIndex] = page;\n return page;\n });\n this.pagePromises[pageIndex] = promise;\n return promise;\n }\n\n getPageIndex(ref) {\n return this.messageHandler\n .sendWithPromise(\"GetPageIndex\", {\n ref,\n })\n .catch(function (reason) {\n return Promise.reject(new Error(reason));\n });\n }\n\n getAnnotations(pageIndex, intent) {\n return this.messageHandler.sendWithPromise(\"GetAnnotations\", {\n pageIndex,\n intent,\n });\n }\n\n getDestinations() {\n return this.messageHandler.sendWithPromise(\"GetDestinations\", null);\n }\n\n getDestination(id) {\n if (typeof id !== \"string\") {\n return Promise.reject(new Error(\"Invalid destination request.\"));\n }\n return this.messageHandler.sendWithPromise(\"GetDestination\", {\n id,\n });\n }\n\n getPageLabels() {\n return this.messageHandler.sendWithPromise(\"GetPageLabels\", null);\n }\n\n getPageLayout() {\n return this.messageHandler.sendWithPromise(\"GetPageLayout\", null);\n }\n\n getPageMode() {\n return this.messageHandler.sendWithPromise(\"GetPageMode\", null);\n }\n\n getViewerPreferences() {\n return this.messageHandler.sendWithPromise(\"GetViewerPreferences\", null);\n }\n\n getOpenAction() {\n return this.messageHandler.sendWithPromise(\"GetOpenAction\", null);\n }\n\n getAttachments() {\n return this.messageHandler.sendWithPromise(\"GetAttachments\", null);\n }\n\n getJavaScript() {\n return this.messageHandler.sendWithPromise(\"GetJavaScript\", null);\n }\n\n getOutline() {\n return this.messageHandler.sendWithPromise(\"GetOutline\", null);\n }\n\n getPermissions() {\n return this.messageHandler.sendWithPromise(\"GetPermissions\", null);\n }\n\n getMetadata() {\n return this.messageHandler\n .sendWithPromise(\"GetMetadata\", null)\n .then(results => {\n return {\n info: results[0],\n metadata: results[1] ? new Metadata(results[1]) : null,\n contentDispositionFilename: this._fullReader\n ? this._fullReader.filename\n : null,\n };\n });\n }\n\n getStats() {\n return this.messageHandler.sendWithPromise(\"GetStats\", null);\n }\n\n startCleanup() {\n return this.messageHandler.sendWithPromise(\"Cleanup\", null).then(() => {\n for (let i = 0, ii = this.pageCache.length; i < ii; i++) {\n const page = this.pageCache[i];\n if (page) {\n const cleanupSuccessful = page.cleanup();\n\n if (!cleanupSuccessful) {\n throw new Error(\n `startCleanup: Page ${i + 1} is currently rendering.`\n );\n }\n }\n }\n this.commonObjs.clear();\n this.fontLoader.clear();\n });\n }\n\n get loadingParams() {\n const params = this._params;\n return shadow(this, \"loadingParams\", {\n disableAutoFetch: params.disableAutoFetch,\n disableFontFace: params.disableFontFace,\n });\n }\n}\n\n/**\n * A PDF document and page is built of many objects. E.g. there are objects for\n * fonts, images, rendering code, etc. These objects may get processed inside of\n * a worker. This class implements some basic methods to manage these objects.\n * @ignore\n */\nclass PDFObjects {\n constructor() {\n this._objs = Object.create(null);\n }\n\n /**\n * Ensures there is an object defined for `objId`.\n * @private\n */\n _ensureObj(objId) {\n if (this._objs[objId]) {\n return this._objs[objId];\n }\n return (this._objs[objId] = {\n capability: createPromiseCapability(),\n data: null,\n resolved: false,\n });\n }\n\n /**\n * If called *without* callback, this returns the data of `objId` but the\n * object needs to be resolved. If it isn't, this method throws.\n *\n * If called *with* a callback, the callback is called with the data of the\n * object once the object is resolved. That means, if you call this method\n * and the object is already resolved, the callback gets called right away.\n */\n get(objId, callback = null) {\n // If there is a callback, then the get can be async and the object is\n // not required to be resolved right now.\n if (callback) {\n this._ensureObj(objId).capability.promise.then(callback);\n return null;\n }\n // If there isn't a callback, the user expects to get the resolved data\n // directly.\n const obj = this._objs[objId];\n // If there isn't an object yet or the object isn't resolved, then the\n // data isn't ready yet!\n if (!obj || !obj.resolved) {\n throw new Error(`Requesting object that isn't resolved yet ${objId}.`);\n }\n return obj.data;\n }\n\n has(objId) {\n const obj = this._objs[objId];\n return obj ? obj.resolved : false;\n }\n\n /**\n * Resolves the object `objId` with optional `data`.\n */\n resolve(objId, data) {\n const obj = this._ensureObj(objId);\n\n obj.resolved = true;\n obj.data = data;\n obj.capability.resolve(data);\n }\n\n clear() {\n this._objs = Object.create(null);\n }\n}\n\n/**\n * Allows controlling of the rendering tasks.\n * @alias RenderTask\n */\nclass RenderTask {\n constructor(internalRenderTask) {\n this._internalRenderTask = internalRenderTask;\n\n /**\n * Callback for incremental rendering -- a function that will be called\n * each time the rendering is paused. To continue rendering call the\n * function that is the first argument to the callback.\n * @type {function}\n */\n this.onContinue = null;\n }\n\n /**\n * Promise for rendering task completion.\n * @type {Promise}\n */\n get promise() {\n return this._internalRenderTask.capability.promise;\n }\n\n /**\n * Cancels the rendering task. If the task is currently rendering it will\n * not be cancelled until graphics pauses with a timeout. The promise that\n * this object extends will be rejected when cancelled.\n */\n cancel() {\n this._internalRenderTask.cancel();\n }\n}\n\n/**\n * For internal use only.\n * @ignore\n */\nconst InternalRenderTask = (function InternalRenderTaskClosure() {\n const canvasInRendering = new WeakSet();\n\n // eslint-disable-next-line no-shadow\n class InternalRenderTask {\n constructor({\n callback,\n params,\n objs,\n commonObjs,\n operatorList,\n pageIndex,\n canvasFactory,\n webGLContext,\n useRequestAnimationFrame = false,\n pdfBug = false,\n }) {\n this.callback = callback;\n this.params = params;\n this.objs = objs;\n this.commonObjs = commonObjs;\n this.operatorListIdx = null;\n this.operatorList = operatorList;\n this._pageIndex = pageIndex;\n this.canvasFactory = canvasFactory;\n this.webGLContext = webGLContext;\n this._pdfBug = pdfBug;\n\n this.running = false;\n this.graphicsReadyCallback = null;\n this.graphicsReady = false;\n this._useRequestAnimationFrame =\n useRequestAnimationFrame === true && typeof window !== \"undefined\";\n this.cancelled = false;\n this.capability = createPromiseCapability();\n this.task = new RenderTask(this);\n // caching this-bound methods\n this._continueBound = this._continue.bind(this);\n this._scheduleNextBound = this._scheduleNext.bind(this);\n this._nextBound = this._next.bind(this);\n this._canvas = params.canvasContext.canvas;\n }\n\n initializeGraphics(transparency = false) {\n if (this.cancelled) {\n return;\n }\n if (this._canvas) {\n if (canvasInRendering.has(this._canvas)) {\n throw new Error(\n \"Cannot use the same canvas during multiple render() operations. \" +\n \"Use different canvas or ensure previous operations were \" +\n \"cancelled or completed.\"\n );\n }\n canvasInRendering.add(this._canvas);\n }\n\n if (\n this._pdfBug &&\n globalThis.StepperManager &&\n globalThis.StepperManager.enabled\n ) {\n this.stepper = globalThis.StepperManager.create(this._pageIndex);\n this.stepper.init(this.operatorList);\n this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint();\n }\n const {\n canvasContext,\n viewport,\n transform,\n imageLayer,\n background,\n } = this.params;\n\n this.gfx = new CanvasGraphics(\n canvasContext,\n this.commonObjs,\n this.objs,\n this.canvasFactory,\n this.webGLContext,\n imageLayer\n );\n this.gfx.beginDrawing({\n transform,\n viewport,\n transparency,\n background,\n });\n this.operatorListIdx = 0;\n this.graphicsReady = true;\n if (this.graphicsReadyCallback) {\n this.graphicsReadyCallback();\n }\n }\n\n cancel(error = null) {\n this.running = false;\n this.cancelled = true;\n if (this.gfx) {\n this.gfx.endDrawing();\n }\n if (this._canvas) {\n canvasInRendering.delete(this._canvas);\n }\n this.callback(\n error ||\n new RenderingCancelledException(\n `Rendering cancelled, page ${this._pageIndex + 1}`,\n \"canvas\"\n )\n );\n }\n\n operatorListChanged() {\n if (!this.graphicsReady) {\n if (!this.graphicsReadyCallback) {\n this.graphicsReadyCallback = this._continueBound;\n }\n return;\n }\n\n if (this.stepper) {\n this.stepper.updateOperatorList(this.operatorList);\n }\n\n if (this.running) {\n return;\n }\n this._continue();\n }\n\n _continue() {\n this.running = true;\n if (this.cancelled) {\n return;\n }\n if (this.task.onContinue) {\n this.task.onContinue(this._scheduleNextBound);\n } else {\n this._scheduleNext();\n }\n }\n\n _scheduleNext() {\n if (this._useRequestAnimationFrame) {\n window.requestAnimationFrame(() => {\n this._nextBound().catch(this.cancel.bind(this));\n });\n } else {\n Promise.resolve().then(this._nextBound).catch(this.cancel.bind(this));\n }\n }\n\n async _next() {\n if (this.cancelled) {\n return;\n }\n this.operatorListIdx = this.gfx.executeOperatorList(\n this.operatorList,\n this.operatorListIdx,\n this._continueBound,\n this.stepper\n );\n if (this.operatorListIdx === this.operatorList.argsArray.length) {\n this.running = false;\n if (this.operatorList.lastChunk) {\n this.gfx.endDrawing();\n if (this._canvas) {\n canvasInRendering.delete(this._canvas);\n }\n this.callback();\n }\n }\n }\n }\n return InternalRenderTask;\n})();\n\nconst version =\n typeof PDFJSDev !== \"undefined\" ? PDFJSDev.eval(\"BUNDLE_VERSION\") : null;\nconst build =\n typeof PDFJSDev !== \"undefined\" ? PDFJSDev.eval(\"BUNDLE_BUILD\") : null;\n\nexport {\n getDocument,\n LoopbackPort,\n PDFDataRangeTransport,\n PDFWorker,\n PDFDocumentProxy,\n PDFPageProxy,\n setPDFNetworkStreamFactory,\n version,\n build,\n};\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n assert,\n bytesToString,\n IsEvalSupportedCached,\n shadow,\n string32,\n unreachable,\n UNSUPPORTED_FEATURES,\n warn,\n} from \"../shared/util.js\";\n\nclass BaseFontLoader {\n constructor({ docId, onUnsupportedFeature }) {\n if (this.constructor === BaseFontLoader) {\n unreachable(\"Cannot initialize BaseFontLoader.\");\n }\n this.docId = docId;\n this._onUnsupportedFeature = onUnsupportedFeature;\n\n this.nativeFontFaces = [];\n this.styleElement = null;\n }\n\n addNativeFontFace(nativeFontFace) {\n this.nativeFontFaces.push(nativeFontFace);\n document.fonts.add(nativeFontFace);\n }\n\n insertRule(rule) {\n let styleElement = this.styleElement;\n if (!styleElement) {\n styleElement = this.styleElement = document.createElement(\"style\");\n styleElement.id = `PDFJS_FONT_STYLE_TAG_${this.docId}`;\n document.documentElement\n .getElementsByTagName(\"head\")[0]\n .appendChild(styleElement);\n }\n\n const styleSheet = styleElement.sheet;\n styleSheet.insertRule(rule, styleSheet.cssRules.length);\n }\n\n clear() {\n this.nativeFontFaces.forEach(function (nativeFontFace) {\n document.fonts.delete(nativeFontFace);\n });\n this.nativeFontFaces.length = 0;\n\n if (this.styleElement) {\n // Note: ChildNode.remove doesn't throw if the parentNode is undefined.\n this.styleElement.remove();\n this.styleElement = null;\n }\n }\n\n async bind(font) {\n // Add the font to the DOM only once; skip if the font is already loaded.\n if (font.attached || font.missingFile) {\n return;\n }\n font.attached = true;\n\n if (this.isFontLoadingAPISupported) {\n const nativeFontFace = font.createNativeFontFace();\n if (nativeFontFace) {\n this.addNativeFontFace(nativeFontFace);\n try {\n await nativeFontFace.loaded;\n } catch (ex) {\n this._onUnsupportedFeature({\n featureId: UNSUPPORTED_FEATURES.errorFontLoadNative,\n });\n warn(`Failed to load font '${nativeFontFace.family}': '${ex}'.`);\n\n // When font loading failed, fall back to the built-in font renderer.\n font.disableFontFace = true;\n throw ex;\n }\n }\n return; // The font was, asynchronously, loaded.\n }\n\n // !this.isFontLoadingAPISupported\n const rule = font.createFontFaceRule();\n if (rule) {\n this.insertRule(rule);\n\n if (this.isSyncFontLoadingSupported) {\n return; // The font was, synchronously, loaded.\n }\n await new Promise(resolve => {\n const request = this._queueLoadingCallback(resolve);\n this._prepareFontLoadEvent([rule], [font], request);\n });\n // The font was, asynchronously, loaded.\n }\n }\n\n _queueLoadingCallback(callback) {\n unreachable(\"Abstract method `_queueLoadingCallback`.\");\n }\n\n get isFontLoadingAPISupported() {\n const supported = typeof document !== \"undefined\" && !!document.fonts;\n return shadow(this, \"isFontLoadingAPISupported\", supported);\n }\n\n // eslint-disable-next-line getter-return\n get isSyncFontLoadingSupported() {\n unreachable(\"Abstract method `isSyncFontLoadingSupported`.\");\n }\n\n // eslint-disable-next-line getter-return\n get _loadTestFont() {\n unreachable(\"Abstract method `_loadTestFont`.\");\n }\n\n _prepareFontLoadEvent(rules, fontsToLoad, request) {\n unreachable(\"Abstract method `_prepareFontLoadEvent`.\");\n }\n}\n\nlet FontLoader;\nif (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"MOZCENTRAL\")) {\n FontLoader = class MozcentralFontLoader extends BaseFontLoader {\n get isSyncFontLoadingSupported() {\n return shadow(this, \"isSyncFontLoadingSupported\", true);\n }\n };\n} else {\n // PDFJSDev.test('CHROME || GENERIC')\n\n FontLoader = class GenericFontLoader extends BaseFontLoader {\n constructor(docId) {\n super(docId);\n this.loadingContext = {\n requests: [],\n nextRequestId: 0,\n };\n this.loadTestFontId = 0;\n }\n\n get isSyncFontLoadingSupported() {\n let supported = false;\n if (typeof PDFJSDev === \"undefined\" || !PDFJSDev.test(\"CHROME\")) {\n if (typeof navigator === \"undefined\") {\n // Node.js - we can pretend that sync font loading is supported.\n supported = true;\n } else {\n // User agent string sniffing is bad, but there is no reliable way to\n // tell if the font is fully loaded and ready to be used with canvas.\n const m = /Mozilla\\/5.0.*?rv:(\\d+).*? Gecko/.exec(\n navigator.userAgent\n );\n if (m && m[1] >= 14) {\n supported = true;\n }\n // TODO - other browsers...\n }\n }\n return shadow(this, \"isSyncFontLoadingSupported\", supported);\n }\n\n _queueLoadingCallback(callback) {\n function completeRequest() {\n assert(!request.done, \"completeRequest() cannot be called twice.\");\n request.done = true;\n\n // Sending all completed requests in order of how they were queued.\n while (context.requests.length > 0 && context.requests[0].done) {\n const otherRequest = context.requests.shift();\n setTimeout(otherRequest.callback, 0);\n }\n }\n\n const context = this.loadingContext;\n const request = {\n id: `pdfjs-font-loading-${context.nextRequestId++}`,\n done: false,\n complete: completeRequest,\n callback,\n };\n context.requests.push(request);\n return request;\n }\n\n get _loadTestFont() {\n const getLoadTestFont = function () {\n // This is a CFF font with 1 glyph for '.' that fills its entire width\n // and height.\n return atob(\n \"T1RUTwALAIAAAwAwQ0ZGIDHtZg4AAAOYAAAAgUZGVE1lkzZwAAAEHAAAABxHREVGABQA\" +\n \"FQAABDgAAAAeT1MvMlYNYwkAAAEgAAAAYGNtYXABDQLUAAACNAAAAUJoZWFk/xVFDQAA\" +\n \"ALwAAAA2aGhlYQdkA+oAAAD0AAAAJGhtdHgD6AAAAAAEWAAAAAZtYXhwAAJQAAAAARgA\" +\n \"AAAGbmFtZVjmdH4AAAGAAAAAsXBvc3T/hgAzAAADeAAAACAAAQAAAAEAALZRFsRfDzz1\" +\n \"AAsD6AAAAADOBOTLAAAAAM4KHDwAAAAAA+gDIQAAAAgAAgAAAAAAAAABAAADIQAAAFoD\" +\n \"6AAAAAAD6AABAAAAAAAAAAAAAAAAAAAAAQAAUAAAAgAAAAQD6AH0AAUAAAKKArwAAACM\" +\n \"AooCvAAAAeAAMQECAAACAAYJAAAAAAAAAAAAAQAAAAAAAAAAAAAAAFBmRWQAwAAuAC4D\" +\n \"IP84AFoDIQAAAAAAAQAAAAAAAAAAACAAIAABAAAADgCuAAEAAAAAAAAAAQAAAAEAAAAA\" +\n \"AAEAAQAAAAEAAAAAAAIAAQAAAAEAAAAAAAMAAQAAAAEAAAAAAAQAAQAAAAEAAAAAAAUA\" +\n \"AQAAAAEAAAAAAAYAAQAAAAMAAQQJAAAAAgABAAMAAQQJAAEAAgABAAMAAQQJAAIAAgAB\" +\n \"AAMAAQQJAAMAAgABAAMAAQQJAAQAAgABAAMAAQQJAAUAAgABAAMAAQQJAAYAAgABWABY\" +\n \"AAAAAAAAAwAAAAMAAAAcAAEAAAAAADwAAwABAAAAHAAEACAAAAAEAAQAAQAAAC7//wAA\" +\n \"AC7////TAAEAAAAAAAABBgAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\" +\n \"AAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\" +\n \"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\" +\n \"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\" +\n \"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA\" +\n \"AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAD/gwAyAAAAAQAAAAAAAAAAAAAAAAAA\" +\n \"AAABAAQEAAEBAQJYAAEBASH4DwD4GwHEAvgcA/gXBIwMAYuL+nz5tQXkD5j3CBLnEQAC\" +\n \"AQEBIVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYAAABAQAADwACAQEEE/t3\" +\n \"Dov6fAH6fAT+fPp8+nwHDosMCvm1Cvm1DAz6fBQAAAAAAAABAAAAAMmJbzEAAAAAzgTj\" +\n \"FQAAAADOBOQpAAEAAAAAAAAADAAUAAQAAAABAAAAAgABAAAAAAAAAAAD6AAAAAAAAA==\"\n );\n };\n return shadow(this, \"_loadTestFont\", getLoadTestFont());\n }\n\n _prepareFontLoadEvent(rules, fonts, request) {\n /** Hack begin */\n // There's currently no event when a font has finished downloading so the\n // following code is a dirty hack to 'guess' when a font is ready.\n // It's assumed fonts are loaded in order, so add a known test font after\n // the desired fonts and then test for the loading of that test font.\n\n function int32(data, offset) {\n return (\n (data.charCodeAt(offset) << 24) |\n (data.charCodeAt(offset + 1) << 16) |\n (data.charCodeAt(offset + 2) << 8) |\n (data.charCodeAt(offset + 3) & 0xff)\n );\n }\n function spliceString(s, offset, remove, insert) {\n const chunk1 = s.substring(0, offset);\n const chunk2 = s.substring(offset + remove);\n return chunk1 + insert + chunk2;\n }\n let i, ii;\n\n // The temporary canvas is used to determine if fonts are loaded.\n const canvas = document.createElement(\"canvas\");\n canvas.width = 1;\n canvas.height = 1;\n const ctx = canvas.getContext(\"2d\");\n\n let called = 0;\n function isFontReady(name, callback) {\n called++;\n // With setTimeout clamping this gives the font ~100ms to load.\n if (called > 30) {\n warn(\"Load test font never loaded.\");\n callback();\n return;\n }\n ctx.font = \"30px \" + name;\n ctx.fillText(\".\", 0, 20);\n const imageData = ctx.getImageData(0, 0, 1, 1);\n if (imageData.data[3] > 0) {\n callback();\n return;\n }\n setTimeout(isFontReady.bind(null, name, callback));\n }\n\n const loadTestFontId = `lt${Date.now()}${this.loadTestFontId++}`;\n // Chromium seems to cache fonts based on a hash of the actual font data,\n // so the font must be modified for each load test else it will appear to\n // be loaded already.\n // TODO: This could maybe be made faster by avoiding the btoa of the full\n // font by splitting it in chunks before hand and padding the font id.\n let data = this._loadTestFont;\n const COMMENT_OFFSET = 976; // has to be on 4 byte boundary (for checksum)\n data = spliceString(\n data,\n COMMENT_OFFSET,\n loadTestFontId.length,\n loadTestFontId\n );\n // CFF checksum is important for IE, adjusting it\n const CFF_CHECKSUM_OFFSET = 16;\n const XXXX_VALUE = 0x58585858; // the \"comment\" filled with 'X'\n let checksum = int32(data, CFF_CHECKSUM_OFFSET);\n for (i = 0, ii = loadTestFontId.length - 3; i < ii; i += 4) {\n checksum = (checksum - XXXX_VALUE + int32(loadTestFontId, i)) | 0;\n }\n if (i < loadTestFontId.length) {\n // align to 4 bytes boundary\n checksum =\n (checksum - XXXX_VALUE + int32(loadTestFontId + \"XXX\", i)) | 0;\n }\n data = spliceString(data, CFF_CHECKSUM_OFFSET, 4, string32(checksum));\n\n const url = `url(data:font/opentype;base64,${btoa(data)});`;\n const rule = `@font-face {font-family:\"${loadTestFontId}\";src:${url}}`;\n this.insertRule(rule);\n\n const names = [];\n for (i = 0, ii = fonts.length; i < ii; i++) {\n names.push(fonts[i].loadedName);\n }\n names.push(loadTestFontId);\n\n const div = document.createElement(\"div\");\n div.style.visibility = \"hidden\";\n div.style.width = div.style.height = \"10px\";\n div.style.position = \"absolute\";\n div.style.top = div.style.left = \"0px\";\n\n for (i = 0, ii = names.length; i < ii; ++i) {\n const span = document.createElement(\"span\");\n span.textContent = \"Hi\";\n span.style.fontFamily = names[i];\n div.appendChild(span);\n }\n document.body.appendChild(div);\n\n isFontReady(loadTestFontId, function () {\n document.body.removeChild(div);\n request.complete();\n });\n /** Hack end */\n }\n };\n} // End of PDFJSDev.test('CHROME || GENERIC')\n\nclass FontFaceObject {\n constructor(\n translatedData,\n {\n isEvalSupported = true,\n disableFontFace = false,\n ignoreErrors = false,\n onUnsupportedFeature = null,\n fontRegistry = null,\n }\n ) {\n this.compiledGlyphs = Object.create(null);\n // importing translated data\n for (const i in translatedData) {\n this[i] = translatedData[i];\n }\n this.isEvalSupported = isEvalSupported !== false;\n this.disableFontFace = disableFontFace === true;\n this.ignoreErrors = ignoreErrors === true;\n this._onUnsupportedFeature = onUnsupportedFeature;\n this.fontRegistry = fontRegistry;\n }\n\n createNativeFontFace() {\n if (!this.data || this.disableFontFace) {\n return null;\n }\n const nativeFontFace = new FontFace(this.loadedName, this.data, {});\n\n if (this.fontRegistry) {\n this.fontRegistry.registerFont(this);\n }\n return nativeFontFace;\n }\n\n createFontFaceRule() {\n if (!this.data || this.disableFontFace) {\n return null;\n }\n const data = bytesToString(new Uint8Array(this.data));\n // Add the @font-face rule to the document.\n const url = `url(data:${this.mimetype};base64,${btoa(data)});`;\n const rule = `@font-face {font-family:\"${this.loadedName}\";src:${url}}`;\n\n if (this.fontRegistry) {\n this.fontRegistry.registerFont(this, url);\n }\n return rule;\n }\n\n getPathGenerator(objs, character) {\n if (this.compiledGlyphs[character] !== undefined) {\n return this.compiledGlyphs[character];\n }\n\n let cmds, current;\n try {\n cmds = objs.get(this.loadedName + \"_path_\" + character);\n } catch (ex) {\n if (!this.ignoreErrors) {\n throw ex;\n }\n if (this._onUnsupportedFeature) {\n this._onUnsupportedFeature({\n featureId: UNSUPPORTED_FEATURES.errorFontGetPath,\n });\n }\n warn(`getPathGenerator - ignoring character: \"${ex}\".`);\n\n return (this.compiledGlyphs[character] = function (c, size) {\n // No-op function, to allow rendering to continue.\n });\n }\n\n // If we can, compile cmds into JS for MAXIMUM SPEED...\n if (this.isEvalSupported && IsEvalSupportedCached.value) {\n let args,\n js = \"\";\n for (let i = 0, ii = cmds.length; i < ii; i++) {\n current = cmds[i];\n\n if (current.args !== undefined) {\n args = current.args.join(\",\");\n } else {\n args = \"\";\n }\n js += \"c.\" + current.cmd + \"(\" + args + \");\\n\";\n }\n // eslint-disable-next-line no-new-func\n return (this.compiledGlyphs[character] = new Function(\"c\", \"size\", js));\n }\n // ... but fall back on using Function.prototype.apply() if we're\n // blocked from using eval() for whatever reason (like CSP policies).\n return (this.compiledGlyphs[character] = function (c, size) {\n for (let i = 0, ii = cmds.length; i < ii; i++) {\n current = cmds[i];\n\n if (current.cmd === \"scale\") {\n current.args = [size, -size];\n }\n c[current.cmd].apply(c, current.args);\n }\n });\n }\n}\n\nexport { FontFaceObject, FontLoader };\n","/* Copyright 2018 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { isNodeJS } from \"../shared/is_node.js\";\n\nconst compatibilityParams = Object.create(null);\nif (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) {\n // Support: Node.js\n (function checkFontFace() {\n // Node.js is missing native support for `@font-face`.\n if (isNodeJS) {\n compatibilityParams.disableFontFace = true;\n }\n })();\n}\nconst apiCompatibilityParams = Object.freeze(compatibilityParams);\n\nexport { apiCompatibilityParams };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n FONT_IDENTITY_MATRIX,\n IDENTITY_MATRIX,\n ImageKind,\n info,\n IsLittleEndianCached,\n isNum,\n OPS,\n shadow,\n TextRenderingMode,\n unreachable,\n Util,\n warn,\n} from \"../shared/util.js\";\nimport { getShadingPatternFromIR, TilingPattern } from \"./pattern_helper.js\";\n\n// <canvas> contexts store most of the state we need natively.\n// However, PDF needs a bit more state, which we store here.\n\n// Minimal font size that would be used during canvas fillText operations.\nvar MIN_FONT_SIZE = 16;\n// Maximum font size that would be used during canvas fillText operations.\nvar MAX_FONT_SIZE = 100;\nvar MAX_GROUP_SIZE = 4096;\n\n// Heuristic value used when enforcing minimum line widths.\nvar MIN_WIDTH_FACTOR = 0.65;\n\nvar COMPILE_TYPE3_GLYPHS = true;\nvar MAX_SIZE_TO_COMPILE = 1000;\n\nvar FULL_CHUNK_HEIGHT = 16;\n\nfunction addContextCurrentTransform(ctx) {\n // If the context doesn't expose a `mozCurrentTransform`, add a JS based one.\n if (!ctx.mozCurrentTransform) {\n ctx._originalSave = ctx.save;\n ctx._originalRestore = ctx.restore;\n ctx._originalRotate = ctx.rotate;\n ctx._originalScale = ctx.scale;\n ctx._originalTranslate = ctx.translate;\n ctx._originalTransform = ctx.transform;\n ctx._originalSetTransform = ctx.setTransform;\n\n ctx._transformMatrix = ctx._transformMatrix || [1, 0, 0, 1, 0, 0];\n ctx._transformStack = [];\n\n Object.defineProperty(ctx, \"mozCurrentTransform\", {\n get: function getCurrentTransform() {\n return this._transformMatrix;\n },\n });\n\n Object.defineProperty(ctx, \"mozCurrentTransformInverse\", {\n get: function getCurrentTransformInverse() {\n // Calculation done using WolframAlpha:\n // http://www.wolframalpha.com/input/?\n // i=Inverse+{{a%2C+c%2C+e}%2C+{b%2C+d%2C+f}%2C+{0%2C+0%2C+1}}\n\n var m = this._transformMatrix;\n var a = m[0],\n b = m[1],\n c = m[2],\n d = m[3],\n e = m[4],\n f = m[5];\n\n var ad_bc = a * d - b * c;\n var bc_ad = b * c - a * d;\n\n return [\n d / ad_bc,\n b / bc_ad,\n c / bc_ad,\n a / ad_bc,\n (d * e - c * f) / bc_ad,\n (b * e - a * f) / ad_bc,\n ];\n },\n });\n\n ctx.save = function ctxSave() {\n var old = this._transformMatrix;\n this._transformStack.push(old);\n this._transformMatrix = old.slice(0, 6);\n\n this._originalSave();\n };\n\n ctx.restore = function ctxRestore() {\n var prev = this._transformStack.pop();\n if (prev) {\n this._transformMatrix = prev;\n this._originalRestore();\n }\n };\n\n ctx.translate = function ctxTranslate(x, y) {\n var m = this._transformMatrix;\n m[4] = m[0] * x + m[2] * y + m[4];\n m[5] = m[1] * x + m[3] * y + m[5];\n\n this._originalTranslate(x, y);\n };\n\n ctx.scale = function ctxScale(x, y) {\n var m = this._transformMatrix;\n m[0] = m[0] * x;\n m[1] = m[1] * x;\n m[2] = m[2] * y;\n m[3] = m[3] * y;\n\n this._originalScale(x, y);\n };\n\n ctx.transform = function ctxTransform(a, b, c, d, e, f) {\n var m = this._transformMatrix;\n this._transformMatrix = [\n m[0] * a + m[2] * b,\n m[1] * a + m[3] * b,\n m[0] * c + m[2] * d,\n m[1] * c + m[3] * d,\n m[0] * e + m[2] * f + m[4],\n m[1] * e + m[3] * f + m[5],\n ];\n\n ctx._originalTransform(a, b, c, d, e, f);\n };\n\n ctx.setTransform = function ctxSetTransform(a, b, c, d, e, f) {\n this._transformMatrix = [a, b, c, d, e, f];\n\n ctx._originalSetTransform(a, b, c, d, e, f);\n };\n\n ctx.rotate = function ctxRotate(angle) {\n var cosValue = Math.cos(angle);\n var sinValue = Math.sin(angle);\n\n var m = this._transformMatrix;\n this._transformMatrix = [\n m[0] * cosValue + m[2] * sinValue,\n m[1] * cosValue + m[3] * sinValue,\n m[0] * -sinValue + m[2] * cosValue,\n m[1] * -sinValue + m[3] * cosValue,\n m[4],\n m[5],\n ];\n\n this._originalRotate(angle);\n };\n }\n}\n\nvar CachedCanvases = (function CachedCanvasesClosure() {\n // eslint-disable-next-line no-shadow\n function CachedCanvases(canvasFactory) {\n this.canvasFactory = canvasFactory;\n this.cache = Object.create(null);\n }\n CachedCanvases.prototype = {\n getCanvas: function CachedCanvases_getCanvas(\n id,\n width,\n height,\n trackTransform\n ) {\n var canvasEntry;\n if (this.cache[id] !== undefined) {\n canvasEntry = this.cache[id];\n this.canvasFactory.reset(canvasEntry, width, height);\n // reset canvas transform for emulated mozCurrentTransform, if needed\n canvasEntry.context.setTransform(1, 0, 0, 1, 0, 0);\n } else {\n canvasEntry = this.canvasFactory.create(width, height);\n this.cache[id] = canvasEntry;\n }\n if (trackTransform) {\n addContextCurrentTransform(canvasEntry.context);\n }\n return canvasEntry;\n },\n clear() {\n for (var id in this.cache) {\n var canvasEntry = this.cache[id];\n this.canvasFactory.destroy(canvasEntry);\n delete this.cache[id];\n }\n },\n };\n return CachedCanvases;\n})();\n\nfunction compileType3Glyph(imgData) {\n var POINT_TO_PROCESS_LIMIT = 1000;\n\n var width = imgData.width,\n height = imgData.height;\n var i,\n j,\n j0,\n width1 = width + 1;\n var points = new Uint8Array(width1 * (height + 1));\n // prettier-ignore\n var POINT_TYPES =\n new Uint8Array([0, 2, 4, 0, 1, 0, 5, 4, 8, 10, 0, 8, 0, 2, 1, 0]);\n\n // decodes bit-packed mask data\n var lineSize = (width + 7) & ~7,\n data0 = imgData.data;\n var data = new Uint8Array(lineSize * height),\n pos = 0,\n ii;\n for (i = 0, ii = data0.length; i < ii; i++) {\n var mask = 128,\n elem = data0[i];\n while (mask > 0) {\n data[pos++] = elem & mask ? 0 : 255;\n mask >>= 1;\n }\n }\n\n // finding interesting points: every point is located between mask pixels,\n // so there will be points of the (width + 1)x(height + 1) grid. Every point\n // will have flags assigned based on neighboring mask pixels:\n // 4 | 8\n // --P--\n // 2 | 1\n // We are interested only in points with the flags:\n // - outside corners: 1, 2, 4, 8;\n // - inside corners: 7, 11, 13, 14;\n // - and, intersections: 5, 10.\n var count = 0;\n pos = 0;\n if (data[pos] !== 0) {\n points[0] = 1;\n ++count;\n }\n for (j = 1; j < width; j++) {\n if (data[pos] !== data[pos + 1]) {\n points[j] = data[pos] ? 2 : 1;\n ++count;\n }\n pos++;\n }\n if (data[pos] !== 0) {\n points[j] = 2;\n ++count;\n }\n for (i = 1; i < height; i++) {\n pos = i * lineSize;\n j0 = i * width1;\n if (data[pos - lineSize] !== data[pos]) {\n points[j0] = data[pos] ? 1 : 8;\n ++count;\n }\n // 'sum' is the position of the current pixel configuration in the 'TYPES'\n // array (in order 8-1-2-4, so we can use '>>2' to shift the column).\n var sum = (data[pos] ? 4 : 0) + (data[pos - lineSize] ? 8 : 0);\n for (j = 1; j < width; j++) {\n sum =\n (sum >> 2) +\n (data[pos + 1] ? 4 : 0) +\n (data[pos - lineSize + 1] ? 8 : 0);\n if (POINT_TYPES[sum]) {\n points[j0 + j] = POINT_TYPES[sum];\n ++count;\n }\n pos++;\n }\n if (data[pos - lineSize] !== data[pos]) {\n points[j0 + j] = data[pos] ? 2 : 4;\n ++count;\n }\n\n if (count > POINT_TO_PROCESS_LIMIT) {\n return null;\n }\n }\n\n pos = lineSize * (height - 1);\n j0 = i * width1;\n if (data[pos] !== 0) {\n points[j0] = 8;\n ++count;\n }\n for (j = 1; j < width; j++) {\n if (data[pos] !== data[pos + 1]) {\n points[j0 + j] = data[pos] ? 4 : 8;\n ++count;\n }\n pos++;\n }\n if (data[pos] !== 0) {\n points[j0 + j] = 4;\n ++count;\n }\n if (count > POINT_TO_PROCESS_LIMIT) {\n return null;\n }\n\n // building outlines\n var steps = new Int32Array([0, width1, -1, 0, -width1, 0, 0, 0, 1]);\n var outlines = [];\n for (i = 0; count && i <= height; i++) {\n var p = i * width1;\n var end = p + width;\n while (p < end && !points[p]) {\n p++;\n }\n if (p === end) {\n continue;\n }\n var coords = [p % width1, i];\n\n var type = points[p],\n p0 = p,\n pp;\n do {\n var step = steps[type];\n do {\n p += step;\n } while (!points[p]);\n\n pp = points[p];\n if (pp !== 5 && pp !== 10) {\n // set new direction\n type = pp;\n // delete mark\n points[p] = 0;\n } else {\n // type is 5 or 10, ie, a crossing\n // set new direction\n type = pp & ((0x33 * type) >> 4);\n // set new type for \"future hit\"\n points[p] &= (type >> 2) | (type << 2);\n }\n\n coords.push(p % width1);\n coords.push((p / width1) | 0);\n\n if (!points[p]) {\n --count;\n }\n } while (p0 !== p);\n outlines.push(coords);\n --i;\n }\n\n var drawOutline = function (c) {\n c.save();\n // the path shall be painted in [0..1]x[0..1] space\n c.scale(1 / width, -1 / height);\n c.translate(0, -height);\n c.beginPath();\n for (let k = 0, kk = outlines.length; k < kk; k++) {\n var o = outlines[k];\n c.moveTo(o[0], o[1]);\n for (let l = 2, ll = o.length; l < ll; l += 2) {\n c.lineTo(o[l], o[l + 1]);\n }\n }\n c.fill();\n c.beginPath();\n c.restore();\n };\n\n return drawOutline;\n}\n\nvar CanvasExtraState = (function CanvasExtraStateClosure() {\n // eslint-disable-next-line no-shadow\n function CanvasExtraState() {\n // Are soft masks and alpha values shapes or opacities?\n this.alphaIsShape = false;\n this.fontSize = 0;\n this.fontSizeScale = 1;\n this.textMatrix = IDENTITY_MATRIX;\n this.textMatrixScale = 1;\n this.fontMatrix = FONT_IDENTITY_MATRIX;\n this.leading = 0;\n // Current point (in user coordinates)\n this.x = 0;\n this.y = 0;\n // Start of text line (in text coordinates)\n this.lineX = 0;\n this.lineY = 0;\n // Character and word spacing\n this.charSpacing = 0;\n this.wordSpacing = 0;\n this.textHScale = 1;\n this.textRenderingMode = TextRenderingMode.FILL;\n this.textRise = 0;\n // Default fore and background colors\n this.fillColor = \"#000000\";\n this.strokeColor = \"#000000\";\n this.patternFill = false;\n // Note: fill alpha applies to all non-stroking operations\n this.fillAlpha = 1;\n this.strokeAlpha = 1;\n this.lineWidth = 1;\n this.activeSMask = null;\n this.resumeSMaskCtx = null; // nonclonable field (see the save method below)\n }\n\n CanvasExtraState.prototype = {\n clone: function CanvasExtraState_clone() {\n return Object.create(this);\n },\n setCurrentPoint: function CanvasExtraState_setCurrentPoint(x, y) {\n this.x = x;\n this.y = y;\n },\n };\n return CanvasExtraState;\n})();\n\nvar CanvasGraphics = (function CanvasGraphicsClosure() {\n // Defines the time the executeOperatorList is going to be executing\n // before it stops and shedules a continue of execution.\n var EXECUTION_TIME = 15;\n // Defines the number of steps before checking the execution time\n var EXECUTION_STEPS = 10;\n\n // eslint-disable-next-line no-shadow\n function CanvasGraphics(\n canvasCtx,\n commonObjs,\n objs,\n canvasFactory,\n webGLContext,\n imageLayer\n ) {\n this.ctx = canvasCtx;\n this.current = new CanvasExtraState();\n this.stateStack = [];\n this.pendingClip = null;\n this.pendingEOFill = false;\n this.res = null;\n this.xobjs = null;\n this.commonObjs = commonObjs;\n this.objs = objs;\n this.canvasFactory = canvasFactory;\n this.webGLContext = webGLContext;\n this.imageLayer = imageLayer;\n this.groupStack = [];\n this.processingType3 = null;\n // Patterns are painted relative to the initial page/form transform, see pdf\n // spec 8.7.2 NOTE 1.\n this.baseTransform = null;\n this.baseTransformStack = [];\n this.groupLevel = 0;\n this.smaskStack = [];\n this.smaskCounter = 0;\n this.tempSMask = null;\n this.cachedCanvases = new CachedCanvases(this.canvasFactory);\n if (canvasCtx) {\n // NOTE: if mozCurrentTransform is polyfilled, then the current state of\n // the transformation must already be set in canvasCtx._transformMatrix.\n addContextCurrentTransform(canvasCtx);\n }\n this._cachedGetSinglePixelWidth = null;\n }\n\n function putBinaryImageData(ctx, imgData) {\n if (typeof ImageData !== \"undefined\" && imgData instanceof ImageData) {\n ctx.putImageData(imgData, 0, 0);\n return;\n }\n\n // Put the image data to the canvas in chunks, rather than putting the\n // whole image at once. This saves JS memory, because the ImageData object\n // is smaller. It also possibly saves C++ memory within the implementation\n // of putImageData(). (E.g. in Firefox we make two short-lived copies of\n // the data passed to putImageData()). |n| shouldn't be too small, however,\n // because too many putImageData() calls will slow things down.\n //\n // Note: as written, if the last chunk is partial, the putImageData() call\n // will (conceptually) put pixels past the bounds of the canvas. But\n // that's ok; any such pixels are ignored.\n\n var height = imgData.height,\n width = imgData.width;\n var partialChunkHeight = height % FULL_CHUNK_HEIGHT;\n var fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;\n var totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;\n\n var chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);\n var srcPos = 0,\n destPos;\n var src = imgData.data;\n var dest = chunkImgData.data;\n var i, j, thisChunkHeight, elemsInThisChunk;\n\n // There are multiple forms in which the pixel data can be passed, and\n // imgData.kind tells us which one this is.\n if (imgData.kind === ImageKind.GRAYSCALE_1BPP) {\n // Grayscale, 1 bit per pixel (i.e. black-and-white).\n var srcLength = src.byteLength;\n var dest32 = new Uint32Array(dest.buffer, 0, dest.byteLength >> 2);\n var dest32DataLength = dest32.length;\n var fullSrcDiff = (width + 7) >> 3;\n var white = 0xffffffff;\n var black = IsLittleEndianCached.value ? 0xff000000 : 0x000000ff;\n for (i = 0; i < totalChunks; i++) {\n thisChunkHeight =\n i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight;\n destPos = 0;\n for (j = 0; j < thisChunkHeight; j++) {\n var srcDiff = srcLength - srcPos;\n var k = 0;\n var kEnd = srcDiff > fullSrcDiff ? width : srcDiff * 8 - 7;\n var kEndUnrolled = kEnd & ~7;\n var mask = 0;\n var srcByte = 0;\n for (; k < kEndUnrolled; k += 8) {\n srcByte = src[srcPos++];\n dest32[destPos++] = srcByte & 128 ? white : black;\n dest32[destPos++] = srcByte & 64 ? white : black;\n dest32[destPos++] = srcByte & 32 ? white : black;\n dest32[destPos++] = srcByte & 16 ? white : black;\n dest32[destPos++] = srcByte & 8 ? white : black;\n dest32[destPos++] = srcByte & 4 ? white : black;\n dest32[destPos++] = srcByte & 2 ? white : black;\n dest32[destPos++] = srcByte & 1 ? white : black;\n }\n for (; k < kEnd; k++) {\n if (mask === 0) {\n srcByte = src[srcPos++];\n mask = 128;\n }\n\n dest32[destPos++] = srcByte & mask ? white : black;\n mask >>= 1;\n }\n }\n // We ran out of input. Make all remaining pixels transparent.\n while (destPos < dest32DataLength) {\n dest32[destPos++] = 0;\n }\n\n ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);\n }\n } else if (imgData.kind === ImageKind.RGBA_32BPP) {\n // RGBA, 32-bits per pixel.\n\n j = 0;\n elemsInThisChunk = width * FULL_CHUNK_HEIGHT * 4;\n for (i = 0; i < fullChunks; i++) {\n dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));\n srcPos += elemsInThisChunk;\n\n ctx.putImageData(chunkImgData, 0, j);\n j += FULL_CHUNK_HEIGHT;\n }\n if (i < totalChunks) {\n elemsInThisChunk = width * partialChunkHeight * 4;\n dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));\n ctx.putImageData(chunkImgData, 0, j);\n }\n } else if (imgData.kind === ImageKind.RGB_24BPP) {\n // RGB, 24-bits per pixel.\n thisChunkHeight = FULL_CHUNK_HEIGHT;\n elemsInThisChunk = width * thisChunkHeight;\n for (i = 0; i < totalChunks; i++) {\n if (i >= fullChunks) {\n thisChunkHeight = partialChunkHeight;\n elemsInThisChunk = width * thisChunkHeight;\n }\n\n destPos = 0;\n for (j = elemsInThisChunk; j--; ) {\n dest[destPos++] = src[srcPos++];\n dest[destPos++] = src[srcPos++];\n dest[destPos++] = src[srcPos++];\n dest[destPos++] = 255;\n }\n ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);\n }\n } else {\n throw new Error(`bad image kind: ${imgData.kind}`);\n }\n }\n\n function putBinaryImageMask(ctx, imgData) {\n var height = imgData.height,\n width = imgData.width;\n var partialChunkHeight = height % FULL_CHUNK_HEIGHT;\n var fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;\n var totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;\n\n var chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);\n var srcPos = 0;\n var src = imgData.data;\n var dest = chunkImgData.data;\n\n for (var i = 0; i < totalChunks; i++) {\n var thisChunkHeight =\n i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight;\n\n // Expand the mask so it can be used by the canvas. Any required\n // inversion has already been handled.\n var destPos = 3; // alpha component offset\n for (var j = 0; j < thisChunkHeight; j++) {\n var mask = 0;\n for (var k = 0; k < width; k++) {\n if (!mask) {\n var elem = src[srcPos++];\n mask = 128;\n }\n dest[destPos] = elem & mask ? 0 : 255;\n destPos += 4;\n mask >>= 1;\n }\n }\n ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);\n }\n }\n\n function copyCtxState(sourceCtx, destCtx) {\n var properties = [\n \"strokeStyle\",\n \"fillStyle\",\n \"fillRule\",\n \"globalAlpha\",\n \"lineWidth\",\n \"lineCap\",\n \"lineJoin\",\n \"miterLimit\",\n \"globalCompositeOperation\",\n \"font\",\n ];\n for (var i = 0, ii = properties.length; i < ii; i++) {\n var property = properties[i];\n if (sourceCtx[property] !== undefined) {\n destCtx[property] = sourceCtx[property];\n }\n }\n if (sourceCtx.setLineDash !== undefined) {\n destCtx.setLineDash(sourceCtx.getLineDash());\n destCtx.lineDashOffset = sourceCtx.lineDashOffset;\n }\n }\n\n function resetCtxToDefault(ctx) {\n ctx.strokeStyle = \"#000000\";\n ctx.fillStyle = \"#000000\";\n ctx.fillRule = \"nonzero\";\n ctx.globalAlpha = 1;\n ctx.lineWidth = 1;\n ctx.lineCap = \"butt\";\n ctx.lineJoin = \"miter\";\n ctx.miterLimit = 10;\n ctx.globalCompositeOperation = \"source-over\";\n ctx.font = \"10px sans-serif\";\n if (ctx.setLineDash !== undefined) {\n ctx.setLineDash([]);\n ctx.lineDashOffset = 0;\n }\n }\n\n function composeSMaskBackdrop(bytes, r0, g0, b0) {\n var length = bytes.length;\n for (var i = 3; i < length; i += 4) {\n var alpha = bytes[i];\n if (alpha === 0) {\n bytes[i - 3] = r0;\n bytes[i - 2] = g0;\n bytes[i - 1] = b0;\n } else if (alpha < 255) {\n var alpha_ = 255 - alpha;\n bytes[i - 3] = (bytes[i - 3] * alpha + r0 * alpha_) >> 8;\n bytes[i - 2] = (bytes[i - 2] * alpha + g0 * alpha_) >> 8;\n bytes[i - 1] = (bytes[i - 1] * alpha + b0 * alpha_) >> 8;\n }\n }\n }\n\n function composeSMaskAlpha(maskData, layerData, transferMap) {\n var length = maskData.length;\n var scale = 1 / 255;\n for (var i = 3; i < length; i += 4) {\n var alpha = transferMap ? transferMap[maskData[i]] : maskData[i];\n layerData[i] = (layerData[i] * alpha * scale) | 0;\n }\n }\n\n function composeSMaskLuminosity(maskData, layerData, transferMap) {\n var length = maskData.length;\n for (var i = 3; i < length; i += 4) {\n var y =\n maskData[i - 3] * 77 + // * 0.3 / 255 * 0x10000\n maskData[i - 2] * 152 + // * 0.59 ....\n maskData[i - 1] * 28; // * 0.11 ....\n layerData[i] = transferMap\n ? (layerData[i] * transferMap[y >> 8]) >> 8\n : (layerData[i] * y) >> 16;\n }\n }\n\n function genericComposeSMask(\n maskCtx,\n layerCtx,\n width,\n height,\n subtype,\n backdrop,\n transferMap\n ) {\n var hasBackdrop = !!backdrop;\n var r0 = hasBackdrop ? backdrop[0] : 0;\n var g0 = hasBackdrop ? backdrop[1] : 0;\n var b0 = hasBackdrop ? backdrop[2] : 0;\n\n var composeFn;\n if (subtype === \"Luminosity\") {\n composeFn = composeSMaskLuminosity;\n } else {\n composeFn = composeSMaskAlpha;\n }\n\n // processing image in chunks to save memory\n var PIXELS_TO_PROCESS = 1048576;\n var chunkSize = Math.min(height, Math.ceil(PIXELS_TO_PROCESS / width));\n for (var row = 0; row < height; row += chunkSize) {\n var chunkHeight = Math.min(chunkSize, height - row);\n var maskData = maskCtx.getImageData(0, row, width, chunkHeight);\n var layerData = layerCtx.getImageData(0, row, width, chunkHeight);\n\n if (hasBackdrop) {\n composeSMaskBackdrop(maskData.data, r0, g0, b0);\n }\n composeFn(maskData.data, layerData.data, transferMap);\n\n maskCtx.putImageData(layerData, 0, row);\n }\n }\n\n function composeSMask(ctx, smask, layerCtx, webGLContext) {\n var mask = smask.canvas;\n var maskCtx = smask.context;\n\n ctx.setTransform(\n smask.scaleX,\n 0,\n 0,\n smask.scaleY,\n smask.offsetX,\n smask.offsetY\n );\n\n var backdrop = smask.backdrop || null;\n if (!smask.transferMap && webGLContext.isEnabled) {\n const composed = webGLContext.composeSMask({\n layer: layerCtx.canvas,\n mask,\n properties: {\n subtype: smask.subtype,\n backdrop,\n },\n });\n ctx.setTransform(1, 0, 0, 1, 0, 0);\n ctx.drawImage(composed, smask.offsetX, smask.offsetY);\n return;\n }\n genericComposeSMask(\n maskCtx,\n layerCtx,\n mask.width,\n mask.height,\n smask.subtype,\n backdrop,\n smask.transferMap\n );\n ctx.drawImage(mask, 0, 0);\n }\n\n var LINE_CAP_STYLES = [\"butt\", \"round\", \"square\"];\n var LINE_JOIN_STYLES = [\"miter\", \"round\", \"bevel\"];\n var NORMAL_CLIP = {};\n var EO_CLIP = {};\n\n CanvasGraphics.prototype = {\n beginDrawing({\n transform,\n viewport,\n transparency = false,\n background = null,\n }) {\n // For pdfs that use blend modes we have to clear the canvas else certain\n // blend modes can look wrong since we'd be blending with a white\n // backdrop. The problem with a transparent backdrop though is we then\n // don't get sub pixel anti aliasing on text, creating temporary\n // transparent canvas when we have blend modes.\n var width = this.ctx.canvas.width;\n var height = this.ctx.canvas.height;\n\n this.ctx.save();\n this.ctx.fillStyle = background || \"rgb(255, 255, 255)\";\n this.ctx.fillRect(0, 0, width, height);\n this.ctx.restore();\n\n if (transparency) {\n var transparentCanvas = this.cachedCanvases.getCanvas(\n \"transparent\",\n width,\n height,\n true\n );\n this.compositeCtx = this.ctx;\n this.transparentCanvas = transparentCanvas.canvas;\n this.ctx = transparentCanvas.context;\n this.ctx.save();\n // The transform can be applied before rendering, transferring it to\n // the new canvas.\n this.ctx.transform.apply(\n this.ctx,\n this.compositeCtx.mozCurrentTransform\n );\n }\n\n this.ctx.save();\n resetCtxToDefault(this.ctx);\n if (transform) {\n this.ctx.transform.apply(this.ctx, transform);\n }\n this.ctx.transform.apply(this.ctx, viewport.transform);\n\n this.baseTransform = this.ctx.mozCurrentTransform.slice();\n\n if (this.imageLayer) {\n this.imageLayer.beginLayout();\n }\n },\n\n executeOperatorList: function CanvasGraphics_executeOperatorList(\n operatorList,\n executionStartIdx,\n continueCallback,\n stepper\n ) {\n var argsArray = operatorList.argsArray;\n var fnArray = operatorList.fnArray;\n var i = executionStartIdx || 0;\n var argsArrayLen = argsArray.length;\n\n // Sometimes the OperatorList to execute is empty.\n if (argsArrayLen === i) {\n return i;\n }\n\n var chunkOperations =\n argsArrayLen - i > EXECUTION_STEPS &&\n typeof continueCallback === \"function\";\n var endTime = chunkOperations ? Date.now() + EXECUTION_TIME : 0;\n var steps = 0;\n\n var commonObjs = this.commonObjs;\n var objs = this.objs;\n var fnId;\n\n while (true) {\n if (stepper !== undefined && i === stepper.nextBreakPoint) {\n stepper.breakIt(i, continueCallback);\n return i;\n }\n\n fnId = fnArray[i];\n\n if (fnId !== OPS.dependency) {\n this[fnId].apply(this, argsArray[i]);\n } else {\n for (const depObjId of argsArray[i]) {\n const objsPool = depObjId.startsWith(\"g_\") ? commonObjs : objs;\n\n // If the promise isn't resolved yet, add the continueCallback\n // to the promise and bail out.\n if (!objsPool.has(depObjId)) {\n objsPool.get(depObjId, continueCallback);\n return i;\n }\n }\n }\n\n i++;\n\n // If the entire operatorList was executed, stop as were done.\n if (i === argsArrayLen) {\n return i;\n }\n\n // If the execution took longer then a certain amount of time and\n // `continueCallback` is specified, interrupt the execution.\n if (chunkOperations && ++steps > EXECUTION_STEPS) {\n if (Date.now() > endTime) {\n continueCallback();\n return i;\n }\n steps = 0;\n }\n\n // If the operatorList isn't executed completely yet OR the execution\n // time was short enough, do another execution round.\n }\n },\n\n endDrawing: function CanvasGraphics_endDrawing() {\n // Finishing all opened operations such as SMask group painting.\n if (this.current.activeSMask !== null) {\n this.endSMaskGroup();\n }\n\n this.ctx.restore();\n\n if (this.transparentCanvas) {\n this.ctx = this.compositeCtx;\n this.ctx.save();\n this.ctx.setTransform(1, 0, 0, 1, 0, 0); // Avoid apply transform twice\n this.ctx.drawImage(this.transparentCanvas, 0, 0);\n this.ctx.restore();\n this.transparentCanvas = null;\n }\n\n this.cachedCanvases.clear();\n this.webGLContext.clear();\n\n if (this.imageLayer) {\n this.imageLayer.endLayout();\n }\n },\n\n // Graphics state\n setLineWidth: function CanvasGraphics_setLineWidth(width) {\n this.current.lineWidth = width;\n this.ctx.lineWidth = width;\n },\n setLineCap: function CanvasGraphics_setLineCap(style) {\n this.ctx.lineCap = LINE_CAP_STYLES[style];\n },\n setLineJoin: function CanvasGraphics_setLineJoin(style) {\n this.ctx.lineJoin = LINE_JOIN_STYLES[style];\n },\n setMiterLimit: function CanvasGraphics_setMiterLimit(limit) {\n this.ctx.miterLimit = limit;\n },\n setDash: function CanvasGraphics_setDash(dashArray, dashPhase) {\n var ctx = this.ctx;\n if (ctx.setLineDash !== undefined) {\n ctx.setLineDash(dashArray);\n ctx.lineDashOffset = dashPhase;\n }\n },\n setRenderingIntent(intent) {\n // This operation is ignored since we haven't found a use case for it yet.\n },\n setFlatness(flatness) {\n // This operation is ignored since we haven't found a use case for it yet.\n },\n setGState: function CanvasGraphics_setGState(states) {\n for (var i = 0, ii = states.length; i < ii; i++) {\n var state = states[i];\n var key = state[0];\n var value = state[1];\n\n switch (key) {\n case \"LW\":\n this.setLineWidth(value);\n break;\n case \"LC\":\n this.setLineCap(value);\n break;\n case \"LJ\":\n this.setLineJoin(value);\n break;\n case \"ML\":\n this.setMiterLimit(value);\n break;\n case \"D\":\n this.setDash(value[0], value[1]);\n break;\n case \"RI\":\n this.setRenderingIntent(value);\n break;\n case \"FL\":\n this.setFlatness(value);\n break;\n case \"Font\":\n this.setFont(value[0], value[1]);\n break;\n case \"CA\":\n this.current.strokeAlpha = state[1];\n break;\n case \"ca\":\n this.current.fillAlpha = state[1];\n this.ctx.globalAlpha = state[1];\n break;\n case \"BM\":\n this.ctx.globalCompositeOperation = value;\n break;\n case \"SMask\":\n if (this.current.activeSMask) {\n // If SMask is currrenly used, it needs to be suspended or\n // finished. Suspend only makes sense when at least one save()\n // was performed and state needs to be reverted on restore().\n if (\n this.stateStack.length > 0 &&\n this.stateStack[this.stateStack.length - 1].activeSMask ===\n this.current.activeSMask\n ) {\n this.suspendSMaskGroup();\n } else {\n this.endSMaskGroup();\n }\n }\n this.current.activeSMask = value ? this.tempSMask : null;\n if (this.current.activeSMask) {\n this.beginSMaskGroup();\n }\n this.tempSMask = null;\n break;\n }\n }\n },\n beginSMaskGroup: function CanvasGraphics_beginSMaskGroup() {\n var activeSMask = this.current.activeSMask;\n var drawnWidth = activeSMask.canvas.width;\n var drawnHeight = activeSMask.canvas.height;\n var cacheId = \"smaskGroupAt\" + this.groupLevel;\n var scratchCanvas = this.cachedCanvases.getCanvas(\n cacheId,\n drawnWidth,\n drawnHeight,\n true\n );\n\n var currentCtx = this.ctx;\n var currentTransform = currentCtx.mozCurrentTransform;\n this.ctx.save();\n\n var groupCtx = scratchCanvas.context;\n groupCtx.scale(1 / activeSMask.scaleX, 1 / activeSMask.scaleY);\n groupCtx.translate(-activeSMask.offsetX, -activeSMask.offsetY);\n groupCtx.transform.apply(groupCtx, currentTransform);\n\n activeSMask.startTransformInverse = groupCtx.mozCurrentTransformInverse;\n\n copyCtxState(currentCtx, groupCtx);\n this.ctx = groupCtx;\n this.setGState([\n [\"BM\", \"source-over\"],\n [\"ca\", 1],\n [\"CA\", 1],\n ]);\n this.groupStack.push(currentCtx);\n this.groupLevel++;\n },\n suspendSMaskGroup: function CanvasGraphics_endSMaskGroup() {\n // Similar to endSMaskGroup, the intermediate canvas has to be composed\n // and future ctx state restored.\n var groupCtx = this.ctx;\n this.groupLevel--;\n this.ctx = this.groupStack.pop();\n\n composeSMask(\n this.ctx,\n this.current.activeSMask,\n groupCtx,\n this.webGLContext\n );\n this.ctx.restore();\n this.ctx.save(); // save is needed since SMask will be resumed.\n copyCtxState(groupCtx, this.ctx);\n\n // Saving state for resuming.\n this.current.resumeSMaskCtx = groupCtx;\n // Transform was changed in the SMask canvas, reflecting this change on\n // this.ctx.\n var deltaTransform = Util.transform(\n this.current.activeSMask.startTransformInverse,\n groupCtx.mozCurrentTransform\n );\n this.ctx.transform.apply(this.ctx, deltaTransform);\n\n // SMask was composed, the results at the groupCtx can be cleared.\n groupCtx.save();\n groupCtx.setTransform(1, 0, 0, 1, 0, 0);\n groupCtx.clearRect(0, 0, groupCtx.canvas.width, groupCtx.canvas.height);\n groupCtx.restore();\n },\n resumeSMaskGroup: function CanvasGraphics_endSMaskGroup() {\n // Resuming state saved by suspendSMaskGroup. We don't need to restore\n // any groupCtx state since restore() command (the only caller) will do\n // that for us. See also beginSMaskGroup.\n var groupCtx = this.current.resumeSMaskCtx;\n var currentCtx = this.ctx;\n this.ctx = groupCtx;\n this.groupStack.push(currentCtx);\n this.groupLevel++;\n },\n endSMaskGroup: function CanvasGraphics_endSMaskGroup() {\n var groupCtx = this.ctx;\n this.groupLevel--;\n this.ctx = this.groupStack.pop();\n\n composeSMask(\n this.ctx,\n this.current.activeSMask,\n groupCtx,\n this.webGLContext\n );\n this.ctx.restore();\n copyCtxState(groupCtx, this.ctx);\n // Transform was changed in the SMask canvas, reflecting this change on\n // this.ctx.\n var deltaTransform = Util.transform(\n this.current.activeSMask.startTransformInverse,\n groupCtx.mozCurrentTransform\n );\n this.ctx.transform.apply(this.ctx, deltaTransform);\n },\n save: function CanvasGraphics_save() {\n this.ctx.save();\n var old = this.current;\n this.stateStack.push(old);\n this.current = old.clone();\n this.current.resumeSMaskCtx = null;\n },\n restore: function CanvasGraphics_restore() {\n // SMask was suspended, we just need to resume it.\n if (this.current.resumeSMaskCtx) {\n this.resumeSMaskGroup();\n }\n // SMask has to be finished once there is no states that are using the\n // same SMask.\n if (\n this.current.activeSMask !== null &&\n (this.stateStack.length === 0 ||\n this.stateStack[this.stateStack.length - 1].activeSMask !==\n this.current.activeSMask)\n ) {\n this.endSMaskGroup();\n }\n\n if (this.stateStack.length !== 0) {\n this.current = this.stateStack.pop();\n this.ctx.restore();\n\n // Ensure that the clipping path is reset (fixes issue6413.pdf).\n this.pendingClip = null;\n\n this._cachedGetSinglePixelWidth = null;\n }\n },\n transform: function CanvasGraphics_transform(a, b, c, d, e, f) {\n this.ctx.transform(a, b, c, d, e, f);\n\n this._cachedGetSinglePixelWidth = null;\n },\n\n // Path\n constructPath: function CanvasGraphics_constructPath(ops, args) {\n var ctx = this.ctx;\n var current = this.current;\n var x = current.x,\n y = current.y;\n for (var i = 0, j = 0, ii = ops.length; i < ii; i++) {\n switch (ops[i] | 0) {\n case OPS.rectangle:\n x = args[j++];\n y = args[j++];\n var width = args[j++];\n var height = args[j++];\n if (width === 0) {\n width = this.getSinglePixelWidth();\n }\n if (height === 0) {\n height = this.getSinglePixelWidth();\n }\n var xw = x + width;\n var yh = y + height;\n this.ctx.moveTo(x, y);\n this.ctx.lineTo(xw, y);\n this.ctx.lineTo(xw, yh);\n this.ctx.lineTo(x, yh);\n this.ctx.lineTo(x, y);\n this.ctx.closePath();\n break;\n case OPS.moveTo:\n x = args[j++];\n y = args[j++];\n ctx.moveTo(x, y);\n break;\n case OPS.lineTo:\n x = args[j++];\n y = args[j++];\n ctx.lineTo(x, y);\n break;\n case OPS.curveTo:\n x = args[j + 4];\n y = args[j + 5];\n ctx.bezierCurveTo(\n args[j],\n args[j + 1],\n args[j + 2],\n args[j + 3],\n x,\n y\n );\n j += 6;\n break;\n case OPS.curveTo2:\n ctx.bezierCurveTo(\n x,\n y,\n args[j],\n args[j + 1],\n args[j + 2],\n args[j + 3]\n );\n x = args[j + 2];\n y = args[j + 3];\n j += 4;\n break;\n case OPS.curveTo3:\n x = args[j + 2];\n y = args[j + 3];\n ctx.bezierCurveTo(args[j], args[j + 1], x, y, x, y);\n j += 4;\n break;\n case OPS.closePath:\n ctx.closePath();\n break;\n }\n }\n current.setCurrentPoint(x, y);\n },\n closePath: function CanvasGraphics_closePath() {\n this.ctx.closePath();\n },\n stroke: function CanvasGraphics_stroke(consumePath) {\n consumePath = typeof consumePath !== \"undefined\" ? consumePath : true;\n var ctx = this.ctx;\n var strokeColor = this.current.strokeColor;\n // For stroke we want to temporarily change the global alpha to the\n // stroking alpha.\n ctx.globalAlpha = this.current.strokeAlpha;\n if (\n strokeColor &&\n strokeColor.hasOwnProperty(\"type\") &&\n strokeColor.type === \"Pattern\"\n ) {\n // for patterns, we transform to pattern space, calculate\n // the pattern, call stroke, and restore to user space\n ctx.save();\n // The current transform will be replaced while building the pattern,\n // but the line width needs to be adjusted by the current transform, so\n // we must scale it. To properly fix this we should be using a pattern\n // transform instead (see #10955).\n const transform = ctx.mozCurrentTransform;\n const scale = Util.singularValueDecompose2dScale(transform)[0];\n ctx.strokeStyle = strokeColor.getPattern(ctx, this);\n ctx.lineWidth = Math.max(\n this.getSinglePixelWidth() * MIN_WIDTH_FACTOR,\n this.current.lineWidth * scale\n );\n ctx.stroke();\n ctx.restore();\n } else {\n // Prevent drawing too thin lines by enforcing a minimum line width.\n ctx.lineWidth = Math.max(\n this.getSinglePixelWidth() * MIN_WIDTH_FACTOR,\n this.current.lineWidth\n );\n ctx.stroke();\n }\n if (consumePath) {\n this.consumePath();\n }\n // Restore the global alpha to the fill alpha\n ctx.globalAlpha = this.current.fillAlpha;\n },\n closeStroke: function CanvasGraphics_closeStroke() {\n this.closePath();\n this.stroke();\n },\n fill: function CanvasGraphics_fill(consumePath) {\n consumePath = typeof consumePath !== \"undefined\" ? consumePath : true;\n var ctx = this.ctx;\n var fillColor = this.current.fillColor;\n var isPatternFill = this.current.patternFill;\n var needRestore = false;\n\n if (isPatternFill) {\n ctx.save();\n if (this.baseTransform) {\n ctx.setTransform.apply(ctx, this.baseTransform);\n }\n ctx.fillStyle = fillColor.getPattern(ctx, this);\n needRestore = true;\n }\n\n if (this.pendingEOFill) {\n ctx.fill(\"evenodd\");\n this.pendingEOFill = false;\n } else {\n ctx.fill();\n }\n\n if (needRestore) {\n ctx.restore();\n }\n if (consumePath) {\n this.consumePath();\n }\n },\n eoFill: function CanvasGraphics_eoFill() {\n this.pendingEOFill = true;\n this.fill();\n },\n fillStroke: function CanvasGraphics_fillStroke() {\n this.fill(false);\n this.stroke(false);\n\n this.consumePath();\n },\n eoFillStroke: function CanvasGraphics_eoFillStroke() {\n this.pendingEOFill = true;\n this.fillStroke();\n },\n closeFillStroke: function CanvasGraphics_closeFillStroke() {\n this.closePath();\n this.fillStroke();\n },\n closeEOFillStroke: function CanvasGraphics_closeEOFillStroke() {\n this.pendingEOFill = true;\n this.closePath();\n this.fillStroke();\n },\n endPath: function CanvasGraphics_endPath() {\n this.consumePath();\n },\n\n // Clipping\n clip: function CanvasGraphics_clip() {\n this.pendingClip = NORMAL_CLIP;\n },\n eoClip: function CanvasGraphics_eoClip() {\n this.pendingClip = EO_CLIP;\n },\n\n // Text\n beginText: function CanvasGraphics_beginText() {\n this.current.textMatrix = IDENTITY_MATRIX;\n this.current.textMatrixScale = 1;\n this.current.x = this.current.lineX = 0;\n this.current.y = this.current.lineY = 0;\n },\n endText: function CanvasGraphics_endText() {\n var paths = this.pendingTextPaths;\n var ctx = this.ctx;\n if (paths === undefined) {\n ctx.beginPath();\n return;\n }\n\n ctx.save();\n ctx.beginPath();\n for (var i = 0; i < paths.length; i++) {\n var path = paths[i];\n ctx.setTransform.apply(ctx, path.transform);\n ctx.translate(path.x, path.y);\n path.addToPath(ctx, path.fontSize);\n }\n ctx.restore();\n ctx.clip();\n ctx.beginPath();\n delete this.pendingTextPaths;\n },\n setCharSpacing: function CanvasGraphics_setCharSpacing(spacing) {\n this.current.charSpacing = spacing;\n },\n setWordSpacing: function CanvasGraphics_setWordSpacing(spacing) {\n this.current.wordSpacing = spacing;\n },\n setHScale: function CanvasGraphics_setHScale(scale) {\n this.current.textHScale = scale / 100;\n },\n setLeading: function CanvasGraphics_setLeading(leading) {\n this.current.leading = -leading;\n },\n setFont: function CanvasGraphics_setFont(fontRefName, size) {\n var fontObj = this.commonObjs.get(fontRefName);\n var current = this.current;\n\n if (!fontObj) {\n throw new Error(`Can't find font for ${fontRefName}`);\n }\n\n current.fontMatrix = fontObj.fontMatrix\n ? fontObj.fontMatrix\n : FONT_IDENTITY_MATRIX;\n\n // A valid matrix needs all main diagonal elements to be non-zero\n // This also ensures we bypass FF bugzilla bug #719844.\n if (current.fontMatrix[0] === 0 || current.fontMatrix[3] === 0) {\n warn(\"Invalid font matrix for font \" + fontRefName);\n }\n\n // The spec for Tf (setFont) says that 'size' specifies the font 'scale',\n // and in some docs this can be negative (inverted x-y axes).\n if (size < 0) {\n size = -size;\n current.fontDirection = -1;\n } else {\n current.fontDirection = 1;\n }\n\n this.current.font = fontObj;\n this.current.fontSize = size;\n\n if (fontObj.isType3Font) {\n return; // we don't need ctx.font for Type3 fonts\n }\n\n var name = fontObj.loadedName || \"sans-serif\";\n\n let bold = \"normal\";\n if (fontObj.black) {\n bold = \"900\";\n } else if (fontObj.bold) {\n bold = \"bold\";\n }\n var italic = fontObj.italic ? \"italic\" : \"normal\";\n var typeface = `\"${name}\", ${fontObj.fallbackName}`;\n\n // Some font backends cannot handle fonts below certain size.\n // Keeping the font at minimal size and using the fontSizeScale to change\n // the current transformation matrix before the fillText/strokeText.\n // See https://bugzilla.mozilla.org/show_bug.cgi?id=726227\n let browserFontSize = size;\n if (size < MIN_FONT_SIZE) {\n browserFontSize = MIN_FONT_SIZE;\n } else if (size > MAX_FONT_SIZE) {\n browserFontSize = MAX_FONT_SIZE;\n }\n this.current.fontSizeScale = size / browserFontSize;\n\n this.ctx.font = `${italic} ${bold} ${browserFontSize}px ${typeface}`;\n },\n setTextRenderingMode: function CanvasGraphics_setTextRenderingMode(mode) {\n this.current.textRenderingMode = mode;\n },\n setTextRise: function CanvasGraphics_setTextRise(rise) {\n this.current.textRise = rise;\n },\n moveText: function CanvasGraphics_moveText(x, y) {\n this.current.x = this.current.lineX += x;\n this.current.y = this.current.lineY += y;\n },\n setLeadingMoveText: function CanvasGraphics_setLeadingMoveText(x, y) {\n this.setLeading(-y);\n this.moveText(x, y);\n },\n setTextMatrix: function CanvasGraphics_setTextMatrix(a, b, c, d, e, f) {\n this.current.textMatrix = [a, b, c, d, e, f];\n this.current.textMatrixScale = Math.sqrt(a * a + b * b);\n\n this.current.x = this.current.lineX = 0;\n this.current.y = this.current.lineY = 0;\n },\n nextLine: function CanvasGraphics_nextLine() {\n this.moveText(0, this.current.leading);\n },\n\n paintChar(character, x, y, patternTransform) {\n var ctx = this.ctx;\n var current = this.current;\n var font = current.font;\n var textRenderingMode = current.textRenderingMode;\n var fontSize = current.fontSize / current.fontSizeScale;\n var fillStrokeMode =\n textRenderingMode & TextRenderingMode.FILL_STROKE_MASK;\n var isAddToPathSet = !!(\n textRenderingMode & TextRenderingMode.ADD_TO_PATH_FLAG\n );\n const patternFill = current.patternFill && !font.missingFile;\n\n var addToPath;\n if (font.disableFontFace || isAddToPathSet || patternFill) {\n addToPath = font.getPathGenerator(this.commonObjs, character);\n }\n\n if (font.disableFontFace || patternFill) {\n ctx.save();\n ctx.translate(x, y);\n ctx.beginPath();\n addToPath(ctx, fontSize);\n if (patternTransform) {\n ctx.setTransform.apply(ctx, patternTransform);\n }\n if (\n fillStrokeMode === TextRenderingMode.FILL ||\n fillStrokeMode === TextRenderingMode.FILL_STROKE\n ) {\n ctx.fill();\n }\n if (\n fillStrokeMode === TextRenderingMode.STROKE ||\n fillStrokeMode === TextRenderingMode.FILL_STROKE\n ) {\n ctx.stroke();\n }\n ctx.restore();\n } else {\n if (\n fillStrokeMode === TextRenderingMode.FILL ||\n fillStrokeMode === TextRenderingMode.FILL_STROKE\n ) {\n ctx.fillText(character, x, y);\n }\n if (\n fillStrokeMode === TextRenderingMode.STROKE ||\n fillStrokeMode === TextRenderingMode.FILL_STROKE\n ) {\n ctx.strokeText(character, x, y);\n }\n }\n\n if (isAddToPathSet) {\n var paths = this.pendingTextPaths || (this.pendingTextPaths = []);\n paths.push({\n transform: ctx.mozCurrentTransform,\n x,\n y,\n fontSize,\n addToPath,\n });\n }\n },\n\n get isFontSubpixelAAEnabled() {\n // Checks if anti-aliasing is enabled when scaled text is painted.\n // On Windows GDI scaled fonts looks bad.\n const { context: ctx } = this.cachedCanvases.getCanvas(\n \"isFontSubpixelAAEnabled\",\n 10,\n 10\n );\n ctx.scale(1.5, 1);\n ctx.fillText(\"I\", 0, 10);\n var data = ctx.getImageData(0, 0, 10, 10).data;\n var enabled = false;\n for (var i = 3; i < data.length; i += 4) {\n if (data[i] > 0 && data[i] < 255) {\n enabled = true;\n break;\n }\n }\n return shadow(this, \"isFontSubpixelAAEnabled\", enabled);\n },\n\n showText: function CanvasGraphics_showText(glyphs) {\n var current = this.current;\n var font = current.font;\n if (font.isType3Font) {\n return this.showType3Text(glyphs);\n }\n\n var fontSize = current.fontSize;\n if (fontSize === 0) {\n return undefined;\n }\n\n var ctx = this.ctx;\n var fontSizeScale = current.fontSizeScale;\n var charSpacing = current.charSpacing;\n var wordSpacing = current.wordSpacing;\n var fontDirection = current.fontDirection;\n var textHScale = current.textHScale * fontDirection;\n var glyphsLength = glyphs.length;\n var vertical = font.vertical;\n var spacingDir = vertical ? 1 : -1;\n var defaultVMetrics = font.defaultVMetrics;\n var widthAdvanceScale = fontSize * current.fontMatrix[0];\n\n var simpleFillText =\n current.textRenderingMode === TextRenderingMode.FILL &&\n !font.disableFontFace &&\n !current.patternFill;\n\n ctx.save();\n let patternTransform;\n if (current.patternFill) {\n // TODO: Patterns are not applied correctly to text if a non-embedded\n // font is used. E.g. issue 8111 and ShowText-ShadingPattern.pdf.\n ctx.save();\n const pattern = current.fillColor.getPattern(ctx, this);\n patternTransform = ctx.mozCurrentTransform;\n ctx.restore();\n ctx.fillStyle = pattern;\n }\n ctx.transform.apply(ctx, current.textMatrix);\n ctx.translate(current.x, current.y + current.textRise);\n\n if (fontDirection > 0) {\n ctx.scale(textHScale, -1);\n } else {\n ctx.scale(textHScale, 1);\n }\n\n var lineWidth = current.lineWidth;\n var scale = current.textMatrixScale;\n if (scale === 0 || lineWidth === 0) {\n var fillStrokeMode =\n current.textRenderingMode & TextRenderingMode.FILL_STROKE_MASK;\n if (\n fillStrokeMode === TextRenderingMode.STROKE ||\n fillStrokeMode === TextRenderingMode.FILL_STROKE\n ) {\n this._cachedGetSinglePixelWidth = null;\n lineWidth = this.getSinglePixelWidth() * MIN_WIDTH_FACTOR;\n }\n } else {\n lineWidth /= scale;\n }\n\n if (fontSizeScale !== 1.0) {\n ctx.scale(fontSizeScale, fontSizeScale);\n lineWidth /= fontSizeScale;\n }\n\n ctx.lineWidth = lineWidth;\n\n var x = 0,\n i;\n for (i = 0; i < glyphsLength; ++i) {\n var glyph = glyphs[i];\n if (isNum(glyph)) {\n x += (spacingDir * glyph * fontSize) / 1000;\n continue;\n }\n\n var restoreNeeded = false;\n var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;\n var character = glyph.fontChar;\n var accent = glyph.accent;\n var scaledX, scaledY, scaledAccentX, scaledAccentY;\n var width = glyph.width;\n if (vertical) {\n var vmetric, vx, vy;\n vmetric = glyph.vmetric || defaultVMetrics;\n vx = glyph.vmetric ? vmetric[1] : width * 0.5;\n vx = -vx * widthAdvanceScale;\n vy = vmetric[2] * widthAdvanceScale;\n\n width = vmetric ? -vmetric[0] : width;\n scaledX = vx / fontSizeScale;\n scaledY = (x + vy) / fontSizeScale;\n } else {\n scaledX = x / fontSizeScale;\n scaledY = 0;\n }\n\n if (font.remeasure && width > 0) {\n // Some standard fonts may not have the exact width: rescale per\n // character if measured width is greater than expected glyph width\n // and subpixel-aa is enabled, otherwise just center the glyph.\n var measuredWidth =\n ((ctx.measureText(character).width * 1000) / fontSize) *\n fontSizeScale;\n if (width < measuredWidth && this.isFontSubpixelAAEnabled) {\n var characterScaleX = width / measuredWidth;\n restoreNeeded = true;\n ctx.save();\n ctx.scale(characterScaleX, 1);\n scaledX /= characterScaleX;\n } else if (width !== measuredWidth) {\n scaledX +=\n (((width - measuredWidth) / 2000) * fontSize) / fontSizeScale;\n }\n }\n\n // Only attempt to draw the glyph if it is actually in the embedded font\n // file or if there isn't a font file so the fallback font is shown.\n if (glyph.isInFont || font.missingFile) {\n if (simpleFillText && !accent) {\n // common case\n ctx.fillText(character, scaledX, scaledY);\n } else {\n this.paintChar(character, scaledX, scaledY, patternTransform);\n if (accent) {\n scaledAccentX = scaledX + accent.offset.x / fontSizeScale;\n scaledAccentY = scaledY - accent.offset.y / fontSizeScale;\n this.paintChar(\n accent.fontChar,\n scaledAccentX,\n scaledAccentY,\n patternTransform\n );\n }\n }\n }\n\n var charWidth;\n if (vertical) {\n charWidth = width * widthAdvanceScale - spacing * fontDirection;\n } else {\n charWidth = width * widthAdvanceScale + spacing * fontDirection;\n }\n x += charWidth;\n\n if (restoreNeeded) {\n ctx.restore();\n }\n }\n if (vertical) {\n current.y -= x;\n } else {\n current.x += x * textHScale;\n }\n ctx.restore();\n },\n\n showType3Text: function CanvasGraphics_showType3Text(glyphs) {\n // Type3 fonts - each glyph is a \"mini-PDF\"\n var ctx = this.ctx;\n var current = this.current;\n var font = current.font;\n var fontSize = current.fontSize;\n var fontDirection = current.fontDirection;\n var spacingDir = font.vertical ? 1 : -1;\n var charSpacing = current.charSpacing;\n var wordSpacing = current.wordSpacing;\n var textHScale = current.textHScale * fontDirection;\n var fontMatrix = current.fontMatrix || FONT_IDENTITY_MATRIX;\n var glyphsLength = glyphs.length;\n var isTextInvisible =\n current.textRenderingMode === TextRenderingMode.INVISIBLE;\n var i, glyph, width, spacingLength;\n\n if (isTextInvisible || fontSize === 0) {\n return;\n }\n this._cachedGetSinglePixelWidth = null;\n\n ctx.save();\n ctx.transform.apply(ctx, current.textMatrix);\n ctx.translate(current.x, current.y);\n\n ctx.scale(textHScale, fontDirection);\n\n for (i = 0; i < glyphsLength; ++i) {\n glyph = glyphs[i];\n if (isNum(glyph)) {\n spacingLength = (spacingDir * glyph * fontSize) / 1000;\n this.ctx.translate(spacingLength, 0);\n current.x += spacingLength * textHScale;\n continue;\n }\n\n var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;\n var operatorList = font.charProcOperatorList[glyph.operatorListId];\n if (!operatorList) {\n warn(`Type3 character \"${glyph.operatorListId}\" is not available.`);\n continue;\n }\n this.processingType3 = glyph;\n this.save();\n ctx.scale(fontSize, fontSize);\n ctx.transform.apply(ctx, fontMatrix);\n this.executeOperatorList(operatorList);\n this.restore();\n\n var transformed = Util.applyTransform([glyph.width, 0], fontMatrix);\n width = transformed[0] * fontSize + spacing;\n\n ctx.translate(width, 0);\n current.x += width * textHScale;\n }\n ctx.restore();\n this.processingType3 = null;\n },\n\n // Type3 fonts\n setCharWidth: function CanvasGraphics_setCharWidth(xWidth, yWidth) {\n // We can safely ignore this since the width should be the same\n // as the width in the Widths array.\n },\n setCharWidthAndBounds: function CanvasGraphics_setCharWidthAndBounds(\n xWidth,\n yWidth,\n llx,\n lly,\n urx,\n ury\n ) {\n // TODO According to the spec we're also suppose to ignore any operators\n // that set color or include images while processing this type3 font.\n this.ctx.rect(llx, lly, urx - llx, ury - lly);\n this.clip();\n this.endPath();\n },\n\n // Color\n getColorN_Pattern: function CanvasGraphics_getColorN_Pattern(IR) {\n var pattern;\n if (IR[0] === \"TilingPattern\") {\n var color = IR[1];\n var baseTransform =\n this.baseTransform || this.ctx.mozCurrentTransform.slice();\n var canvasGraphicsFactory = {\n createCanvasGraphics: ctx => {\n return new CanvasGraphics(\n ctx,\n this.commonObjs,\n this.objs,\n this.canvasFactory,\n this.webGLContext\n );\n },\n };\n pattern = new TilingPattern(\n IR,\n color,\n this.ctx,\n canvasGraphicsFactory,\n baseTransform\n );\n } else {\n pattern = getShadingPatternFromIR(IR);\n }\n return pattern;\n },\n setStrokeColorN: function CanvasGraphics_setStrokeColorN() {\n this.current.strokeColor = this.getColorN_Pattern(arguments);\n },\n setFillColorN: function CanvasGraphics_setFillColorN() {\n this.current.fillColor = this.getColorN_Pattern(arguments);\n this.current.patternFill = true;\n },\n setStrokeRGBColor: function CanvasGraphics_setStrokeRGBColor(r, g, b) {\n var color = Util.makeCssRgb(r, g, b);\n this.ctx.strokeStyle = color;\n this.current.strokeColor = color;\n },\n setFillRGBColor: function CanvasGraphics_setFillRGBColor(r, g, b) {\n var color = Util.makeCssRgb(r, g, b);\n this.ctx.fillStyle = color;\n this.current.fillColor = color;\n this.current.patternFill = false;\n },\n\n shadingFill: function CanvasGraphics_shadingFill(patternIR) {\n var ctx = this.ctx;\n\n this.save();\n var pattern = getShadingPatternFromIR(patternIR);\n ctx.fillStyle = pattern.getPattern(ctx, this, true);\n\n var inv = ctx.mozCurrentTransformInverse;\n if (inv) {\n var canvas = ctx.canvas;\n var width = canvas.width;\n var height = canvas.height;\n\n var bl = Util.applyTransform([0, 0], inv);\n var br = Util.applyTransform([0, height], inv);\n var ul = Util.applyTransform([width, 0], inv);\n var ur = Util.applyTransform([width, height], inv);\n\n var x0 = Math.min(bl[0], br[0], ul[0], ur[0]);\n var y0 = Math.min(bl[1], br[1], ul[1], ur[1]);\n var x1 = Math.max(bl[0], br[0], ul[0], ur[0]);\n var y1 = Math.max(bl[1], br[1], ul[1], ur[1]);\n\n this.ctx.fillRect(x0, y0, x1 - x0, y1 - y0);\n } else {\n // HACK to draw the gradient onto an infinite rectangle.\n // PDF gradients are drawn across the entire image while\n // Canvas only allows gradients to be drawn in a rectangle\n // The following bug should allow us to remove this.\n // https://bugzilla.mozilla.org/show_bug.cgi?id=664884\n\n this.ctx.fillRect(-1e10, -1e10, 2e10, 2e10);\n }\n\n this.restore();\n },\n\n // Images\n beginInlineImage: function CanvasGraphics_beginInlineImage() {\n unreachable(\"Should not call beginInlineImage\");\n },\n beginImageData: function CanvasGraphics_beginImageData() {\n unreachable(\"Should not call beginImageData\");\n },\n\n paintFormXObjectBegin: function CanvasGraphics_paintFormXObjectBegin(\n matrix,\n bbox\n ) {\n this.save();\n this.baseTransformStack.push(this.baseTransform);\n\n if (Array.isArray(matrix) && matrix.length === 6) {\n this.transform.apply(this, matrix);\n }\n\n this.baseTransform = this.ctx.mozCurrentTransform;\n\n if (bbox) {\n var width = bbox[2] - bbox[0];\n var height = bbox[3] - bbox[1];\n this.ctx.rect(bbox[0], bbox[1], width, height);\n this.clip();\n this.endPath();\n }\n },\n\n paintFormXObjectEnd: function CanvasGraphics_paintFormXObjectEnd() {\n this.restore();\n this.baseTransform = this.baseTransformStack.pop();\n },\n\n beginGroup: function CanvasGraphics_beginGroup(group) {\n this.save();\n var currentCtx = this.ctx;\n // TODO non-isolated groups - according to Rik at adobe non-isolated\n // group results aren't usually that different and they even have tools\n // that ignore this setting. Notes from Rik on implementing:\n // - When you encounter an transparency group, create a new canvas with\n // the dimensions of the bbox\n // - copy the content from the previous canvas to the new canvas\n // - draw as usual\n // - remove the backdrop alpha:\n // alphaNew = 1 - (1 - alpha)/(1 - alphaBackdrop) with 'alpha' the alpha\n // value of your transparency group and 'alphaBackdrop' the alpha of the\n // backdrop\n // - remove background color:\n // colorNew = color - alphaNew *colorBackdrop /(1 - alphaNew)\n if (!group.isolated) {\n info(\"TODO: Support non-isolated groups.\");\n }\n\n // TODO knockout - supposedly possible with the clever use of compositing\n // modes.\n if (group.knockout) {\n warn(\"Knockout groups not supported.\");\n }\n\n var currentTransform = currentCtx.mozCurrentTransform;\n if (group.matrix) {\n currentCtx.transform.apply(currentCtx, group.matrix);\n }\n if (!group.bbox) {\n throw new Error(\"Bounding box is required.\");\n }\n\n // Based on the current transform figure out how big the bounding box\n // will actually be.\n var bounds = Util.getAxialAlignedBoundingBox(\n group.bbox,\n currentCtx.mozCurrentTransform\n );\n // Clip the bounding box to the current canvas.\n var canvasBounds = [\n 0,\n 0,\n currentCtx.canvas.width,\n currentCtx.canvas.height,\n ];\n bounds = Util.intersect(bounds, canvasBounds) || [0, 0, 0, 0];\n // Use ceil in case we're between sizes so we don't create canvas that is\n // too small and make the canvas at least 1x1 pixels.\n var offsetX = Math.floor(bounds[0]);\n var offsetY = Math.floor(bounds[1]);\n var drawnWidth = Math.max(Math.ceil(bounds[2]) - offsetX, 1);\n var drawnHeight = Math.max(Math.ceil(bounds[3]) - offsetY, 1);\n var scaleX = 1,\n scaleY = 1;\n if (drawnWidth > MAX_GROUP_SIZE) {\n scaleX = drawnWidth / MAX_GROUP_SIZE;\n drawnWidth = MAX_GROUP_SIZE;\n }\n if (drawnHeight > MAX_GROUP_SIZE) {\n scaleY = drawnHeight / MAX_GROUP_SIZE;\n drawnHeight = MAX_GROUP_SIZE;\n }\n\n var cacheId = \"groupAt\" + this.groupLevel;\n if (group.smask) {\n // Using two cache entries is case if masks are used one after another.\n cacheId += \"_smask_\" + (this.smaskCounter++ % 2);\n }\n var scratchCanvas = this.cachedCanvases.getCanvas(\n cacheId,\n drawnWidth,\n drawnHeight,\n true\n );\n var groupCtx = scratchCanvas.context;\n\n // Since we created a new canvas that is just the size of the bounding box\n // we have to translate the group ctx.\n groupCtx.scale(1 / scaleX, 1 / scaleY);\n groupCtx.translate(-offsetX, -offsetY);\n groupCtx.transform.apply(groupCtx, currentTransform);\n\n if (group.smask) {\n // Saving state and cached mask to be used in setGState.\n this.smaskStack.push({\n canvas: scratchCanvas.canvas,\n context: groupCtx,\n offsetX,\n offsetY,\n scaleX,\n scaleY,\n subtype: group.smask.subtype,\n backdrop: group.smask.backdrop,\n transferMap: group.smask.transferMap || null,\n startTransformInverse: null, // used during suspend operation\n });\n } else {\n // Setup the current ctx so when the group is popped we draw it at the\n // right location.\n currentCtx.setTransform(1, 0, 0, 1, 0, 0);\n currentCtx.translate(offsetX, offsetY);\n currentCtx.scale(scaleX, scaleY);\n }\n // The transparency group inherits all off the current graphics state\n // except the blend mode, soft mask, and alpha constants.\n copyCtxState(currentCtx, groupCtx);\n this.ctx = groupCtx;\n this.setGState([\n [\"BM\", \"source-over\"],\n [\"ca\", 1],\n [\"CA\", 1],\n ]);\n this.groupStack.push(currentCtx);\n this.groupLevel++;\n\n // Reseting mask state, masks will be applied on restore of the group.\n this.current.activeSMask = null;\n },\n\n endGroup: function CanvasGraphics_endGroup(group) {\n this.groupLevel--;\n var groupCtx = this.ctx;\n this.ctx = this.groupStack.pop();\n // Turn off image smoothing to avoid sub pixel interpolation which can\n // look kind of blurry for some pdfs.\n if (this.ctx.imageSmoothingEnabled !== undefined) {\n this.ctx.imageSmoothingEnabled = false;\n } else {\n this.ctx.mozImageSmoothingEnabled = false;\n }\n if (group.smask) {\n this.tempSMask = this.smaskStack.pop();\n } else {\n this.ctx.drawImage(groupCtx.canvas, 0, 0);\n }\n this.restore();\n },\n\n beginAnnotations: function CanvasGraphics_beginAnnotations() {\n this.save();\n if (this.baseTransform) {\n this.ctx.setTransform.apply(this.ctx, this.baseTransform);\n }\n },\n\n endAnnotations: function CanvasGraphics_endAnnotations() {\n this.restore();\n },\n\n beginAnnotation: function CanvasGraphics_beginAnnotation(\n rect,\n transform,\n matrix\n ) {\n this.save();\n resetCtxToDefault(this.ctx);\n this.current = new CanvasExtraState();\n\n if (Array.isArray(rect) && rect.length === 4) {\n var width = rect[2] - rect[0];\n var height = rect[3] - rect[1];\n this.ctx.rect(rect[0], rect[1], width, height);\n this.clip();\n this.endPath();\n }\n\n this.transform.apply(this, transform);\n this.transform.apply(this, matrix);\n },\n\n endAnnotation: function CanvasGraphics_endAnnotation() {\n this.restore();\n },\n\n paintImageMaskXObject: function CanvasGraphics_paintImageMaskXObject(img) {\n var ctx = this.ctx;\n var width = img.width,\n height = img.height;\n var fillColor = this.current.fillColor;\n var isPatternFill = this.current.patternFill;\n\n var glyph = this.processingType3;\n\n if (COMPILE_TYPE3_GLYPHS && glyph && glyph.compiled === undefined) {\n if (width <= MAX_SIZE_TO_COMPILE && height <= MAX_SIZE_TO_COMPILE) {\n glyph.compiled = compileType3Glyph({ data: img.data, width, height });\n } else {\n glyph.compiled = null;\n }\n }\n\n if (glyph && glyph.compiled) {\n glyph.compiled(ctx);\n return;\n }\n\n var maskCanvas = this.cachedCanvases.getCanvas(\n \"maskCanvas\",\n width,\n height\n );\n var maskCtx = maskCanvas.context;\n maskCtx.save();\n\n putBinaryImageMask(maskCtx, img);\n\n maskCtx.globalCompositeOperation = \"source-in\";\n\n maskCtx.fillStyle = isPatternFill\n ? fillColor.getPattern(maskCtx, this)\n : fillColor;\n maskCtx.fillRect(0, 0, width, height);\n\n maskCtx.restore();\n\n this.paintInlineImageXObject(maskCanvas.canvas);\n },\n\n paintImageMaskXObjectRepeat: function CanvasGraphics_paintImageMaskXObjectRepeat(\n imgData,\n scaleX,\n scaleY,\n positions\n ) {\n var width = imgData.width;\n var height = imgData.height;\n var fillColor = this.current.fillColor;\n var isPatternFill = this.current.patternFill;\n\n var maskCanvas = this.cachedCanvases.getCanvas(\n \"maskCanvas\",\n width,\n height\n );\n var maskCtx = maskCanvas.context;\n maskCtx.save();\n\n putBinaryImageMask(maskCtx, imgData);\n\n maskCtx.globalCompositeOperation = \"source-in\";\n\n maskCtx.fillStyle = isPatternFill\n ? fillColor.getPattern(maskCtx, this)\n : fillColor;\n maskCtx.fillRect(0, 0, width, height);\n\n maskCtx.restore();\n\n var ctx = this.ctx;\n for (var i = 0, ii = positions.length; i < ii; i += 2) {\n ctx.save();\n ctx.transform(scaleX, 0, 0, scaleY, positions[i], positions[i + 1]);\n ctx.scale(1, -1);\n ctx.drawImage(maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);\n ctx.restore();\n }\n },\n\n paintImageMaskXObjectGroup: function CanvasGraphics_paintImageMaskXObjectGroup(\n images\n ) {\n var ctx = this.ctx;\n\n var fillColor = this.current.fillColor;\n var isPatternFill = this.current.patternFill;\n for (var i = 0, ii = images.length; i < ii; i++) {\n var image = images[i];\n var width = image.width,\n height = image.height;\n\n var maskCanvas = this.cachedCanvases.getCanvas(\n \"maskCanvas\",\n width,\n height\n );\n var maskCtx = maskCanvas.context;\n maskCtx.save();\n\n putBinaryImageMask(maskCtx, image);\n\n maskCtx.globalCompositeOperation = \"source-in\";\n\n maskCtx.fillStyle = isPatternFill\n ? fillColor.getPattern(maskCtx, this)\n : fillColor;\n maskCtx.fillRect(0, 0, width, height);\n\n maskCtx.restore();\n\n ctx.save();\n ctx.transform.apply(ctx, image.transform);\n ctx.scale(1, -1);\n ctx.drawImage(maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);\n ctx.restore();\n }\n },\n\n paintImageXObject: function CanvasGraphics_paintImageXObject(objId) {\n const imgData = objId.startsWith(\"g_\")\n ? this.commonObjs.get(objId)\n : this.objs.get(objId);\n if (!imgData) {\n warn(\"Dependent image isn't ready yet\");\n return;\n }\n\n this.paintInlineImageXObject(imgData);\n },\n\n paintImageXObjectRepeat: function CanvasGraphics_paintImageXObjectRepeat(\n objId,\n scaleX,\n scaleY,\n positions\n ) {\n const imgData = objId.startsWith(\"g_\")\n ? this.commonObjs.get(objId)\n : this.objs.get(objId);\n if (!imgData) {\n warn(\"Dependent image isn't ready yet\");\n return;\n }\n\n var width = imgData.width;\n var height = imgData.height;\n var map = [];\n for (var i = 0, ii = positions.length; i < ii; i += 2) {\n map.push({\n transform: [scaleX, 0, 0, scaleY, positions[i], positions[i + 1]],\n x: 0,\n y: 0,\n w: width,\n h: height,\n });\n }\n this.paintInlineImageXObjectGroup(imgData, map);\n },\n\n paintInlineImageXObject: function CanvasGraphics_paintInlineImageXObject(\n imgData\n ) {\n var width = imgData.width;\n var height = imgData.height;\n var ctx = this.ctx;\n\n this.save();\n // scale the image to the unit square\n ctx.scale(1 / width, -1 / height);\n\n var currentTransform = ctx.mozCurrentTransformInverse;\n var a = currentTransform[0],\n b = currentTransform[1];\n var widthScale = Math.max(Math.sqrt(a * a + b * b), 1);\n var c = currentTransform[2],\n d = currentTransform[3];\n var heightScale = Math.max(Math.sqrt(c * c + d * d), 1);\n\n var imgToPaint, tmpCanvas;\n // typeof check is needed due to node.js support, see issue #8489\n if (\n (typeof HTMLElement === \"function\" && imgData instanceof HTMLElement) ||\n !imgData.data\n ) {\n imgToPaint = imgData;\n } else {\n tmpCanvas = this.cachedCanvases.getCanvas(\"inlineImage\", width, height);\n var tmpCtx = tmpCanvas.context;\n putBinaryImageData(tmpCtx, imgData);\n imgToPaint = tmpCanvas.canvas;\n }\n\n var paintWidth = width,\n paintHeight = height;\n var tmpCanvasId = \"prescale1\";\n // Vertical or horizontal scaling shall not be more than 2 to not lose the\n // pixels during drawImage operation, painting on the temporary canvas(es)\n // that are twice smaller in size.\n while (\n (widthScale > 2 && paintWidth > 1) ||\n (heightScale > 2 && paintHeight > 1)\n ) {\n var newWidth = paintWidth,\n newHeight = paintHeight;\n if (widthScale > 2 && paintWidth > 1) {\n newWidth = Math.ceil(paintWidth / 2);\n widthScale /= paintWidth / newWidth;\n }\n if (heightScale > 2 && paintHeight > 1) {\n newHeight = Math.ceil(paintHeight / 2);\n heightScale /= paintHeight / newHeight;\n }\n tmpCanvas = this.cachedCanvases.getCanvas(\n tmpCanvasId,\n newWidth,\n newHeight\n );\n tmpCtx = tmpCanvas.context;\n tmpCtx.clearRect(0, 0, newWidth, newHeight);\n tmpCtx.drawImage(\n imgToPaint,\n 0,\n 0,\n paintWidth,\n paintHeight,\n 0,\n 0,\n newWidth,\n newHeight\n );\n imgToPaint = tmpCanvas.canvas;\n paintWidth = newWidth;\n paintHeight = newHeight;\n tmpCanvasId = tmpCanvasId === \"prescale1\" ? \"prescale2\" : \"prescale1\";\n }\n ctx.drawImage(\n imgToPaint,\n 0,\n 0,\n paintWidth,\n paintHeight,\n 0,\n -height,\n width,\n height\n );\n\n if (this.imageLayer) {\n var position = this.getCanvasPosition(0, -height);\n this.imageLayer.appendImage({\n imgData,\n left: position[0],\n top: position[1],\n width: width / currentTransform[0],\n height: height / currentTransform[3],\n });\n }\n this.restore();\n },\n\n paintInlineImageXObjectGroup: function CanvasGraphics_paintInlineImageXObjectGroup(\n imgData,\n map\n ) {\n var ctx = this.ctx;\n var w = imgData.width;\n var h = imgData.height;\n\n var tmpCanvas = this.cachedCanvases.getCanvas(\"inlineImage\", w, h);\n var tmpCtx = tmpCanvas.context;\n putBinaryImageData(tmpCtx, imgData);\n\n for (var i = 0, ii = map.length; i < ii; i++) {\n var entry = map[i];\n ctx.save();\n ctx.transform.apply(ctx, entry.transform);\n ctx.scale(1, -1);\n ctx.drawImage(\n tmpCanvas.canvas,\n entry.x,\n entry.y,\n entry.w,\n entry.h,\n 0,\n -1,\n 1,\n 1\n );\n if (this.imageLayer) {\n var position = this.getCanvasPosition(entry.x, entry.y);\n this.imageLayer.appendImage({\n imgData,\n left: position[0],\n top: position[1],\n width: w,\n height: h,\n });\n }\n ctx.restore();\n }\n },\n\n paintSolidColorImageMask: function CanvasGraphics_paintSolidColorImageMask() {\n this.ctx.fillRect(0, 0, 1, 1);\n },\n\n paintXObject: function CanvasGraphics_paintXObject() {\n warn(\"Unsupported 'paintXObject' command.\");\n },\n\n // Marked content\n\n markPoint: function CanvasGraphics_markPoint(tag) {\n // TODO Marked content.\n },\n markPointProps: function CanvasGraphics_markPointProps(tag, properties) {\n // TODO Marked content.\n },\n beginMarkedContent: function CanvasGraphics_beginMarkedContent(tag) {\n // TODO Marked content.\n },\n beginMarkedContentProps: function CanvasGraphics_beginMarkedContentProps(\n tag,\n properties\n ) {\n // TODO Marked content.\n },\n endMarkedContent: function CanvasGraphics_endMarkedContent() {\n // TODO Marked content.\n },\n\n // Compatibility\n\n beginCompat: function CanvasGraphics_beginCompat() {\n // TODO ignore undefined operators (should we do that anyway?)\n },\n endCompat: function CanvasGraphics_endCompat() {\n // TODO stop ignoring undefined operators\n },\n\n // Helper functions\n\n consumePath: function CanvasGraphics_consumePath() {\n var ctx = this.ctx;\n if (this.pendingClip) {\n if (this.pendingClip === EO_CLIP) {\n ctx.clip(\"evenodd\");\n } else {\n ctx.clip();\n }\n this.pendingClip = null;\n }\n ctx.beginPath();\n },\n getSinglePixelWidth(scale) {\n if (this._cachedGetSinglePixelWidth === null) {\n const inverse = this.ctx.mozCurrentTransformInverse;\n // max of the current horizontal and vertical scale\n this._cachedGetSinglePixelWidth = Math.sqrt(\n Math.max(\n inverse[0] * inverse[0] + inverse[1] * inverse[1],\n inverse[2] * inverse[2] + inverse[3] * inverse[3]\n )\n );\n }\n return this._cachedGetSinglePixelWidth;\n },\n getCanvasPosition: function CanvasGraphics_getCanvasPosition(x, y) {\n var transform = this.ctx.mozCurrentTransform;\n return [\n transform[0] * x + transform[2] * y + transform[4],\n transform[1] * x + transform[3] * y + transform[5],\n ];\n },\n };\n\n for (var op in OPS) {\n CanvasGraphics.prototype[OPS[op]] = CanvasGraphics.prototype[op];\n }\n\n return CanvasGraphics;\n})();\n\nexport { CanvasGraphics };\n","/* Copyright 2014 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FormatError, info, Util } from \"../shared/util.js\";\n\nvar ShadingIRs = {};\n\nfunction applyBoundingBox(ctx, bbox) {\n if (!bbox || typeof Path2D === \"undefined\") {\n return;\n }\n const width = bbox[2] - bbox[0];\n const height = bbox[3] - bbox[1];\n const region = new Path2D();\n region.rect(bbox[0], bbox[1], width, height);\n ctx.clip(region);\n}\n\nShadingIRs.RadialAxial = {\n fromIR: function RadialAxial_fromIR(raw) {\n var type = raw[1];\n var bbox = raw[2];\n var colorStops = raw[3];\n var p0 = raw[4];\n var p1 = raw[5];\n var r0 = raw[6];\n var r1 = raw[7];\n return {\n type: \"Pattern\",\n getPattern: function RadialAxial_getPattern(ctx) {\n applyBoundingBox(ctx, bbox);\n var grad;\n if (type === \"axial\") {\n grad = ctx.createLinearGradient(p0[0], p0[1], p1[0], p1[1]);\n } else if (type === \"radial\") {\n grad = ctx.createRadialGradient(p0[0], p0[1], r0, p1[0], p1[1], r1);\n }\n\n for (var i = 0, ii = colorStops.length; i < ii; ++i) {\n var c = colorStops[i];\n grad.addColorStop(c[0], c[1]);\n }\n return grad;\n },\n };\n },\n};\n\nvar createMeshCanvas = (function createMeshCanvasClosure() {\n function drawTriangle(data, context, p1, p2, p3, c1, c2, c3) {\n // Very basic Gouraud-shaded triangle rasterization algorithm.\n var coords = context.coords,\n colors = context.colors;\n var bytes = data.data,\n rowSize = data.width * 4;\n var tmp;\n if (coords[p1 + 1] > coords[p2 + 1]) {\n tmp = p1;\n p1 = p2;\n p2 = tmp;\n tmp = c1;\n c1 = c2;\n c2 = tmp;\n }\n if (coords[p2 + 1] > coords[p3 + 1]) {\n tmp = p2;\n p2 = p3;\n p3 = tmp;\n tmp = c2;\n c2 = c3;\n c3 = tmp;\n }\n if (coords[p1 + 1] > coords[p2 + 1]) {\n tmp = p1;\n p1 = p2;\n p2 = tmp;\n tmp = c1;\n c1 = c2;\n c2 = tmp;\n }\n var x1 = (coords[p1] + context.offsetX) * context.scaleX;\n var y1 = (coords[p1 + 1] + context.offsetY) * context.scaleY;\n var x2 = (coords[p2] + context.offsetX) * context.scaleX;\n var y2 = (coords[p2 + 1] + context.offsetY) * context.scaleY;\n var x3 = (coords[p3] + context.offsetX) * context.scaleX;\n var y3 = (coords[p3 + 1] + context.offsetY) * context.scaleY;\n if (y1 >= y3) {\n return;\n }\n var c1r = colors[c1],\n c1g = colors[c1 + 1],\n c1b = colors[c1 + 2];\n var c2r = colors[c2],\n c2g = colors[c2 + 1],\n c2b = colors[c2 + 2];\n var c3r = colors[c3],\n c3g = colors[c3 + 1],\n c3b = colors[c3 + 2];\n\n var minY = Math.round(y1),\n maxY = Math.round(y3);\n var xa, car, cag, cab;\n var xb, cbr, cbg, cbb;\n for (var y = minY; y <= maxY; y++) {\n if (y < y2) {\n let k;\n if (y < y1) {\n k = 0;\n } else if (y1 === y2) {\n k = 1;\n } else {\n k = (y1 - y) / (y1 - y2);\n }\n xa = x1 - (x1 - x2) * k;\n car = c1r - (c1r - c2r) * k;\n cag = c1g - (c1g - c2g) * k;\n cab = c1b - (c1b - c2b) * k;\n } else {\n let k;\n if (y > y3) {\n k = 1;\n } else if (y2 === y3) {\n k = 0;\n } else {\n k = (y2 - y) / (y2 - y3);\n }\n xa = x2 - (x2 - x3) * k;\n car = c2r - (c2r - c3r) * k;\n cag = c2g - (c2g - c3g) * k;\n cab = c2b - (c2b - c3b) * k;\n }\n\n let k;\n if (y < y1) {\n k = 0;\n } else if (y > y3) {\n k = 1;\n } else {\n k = (y1 - y) / (y1 - y3);\n }\n xb = x1 - (x1 - x3) * k;\n cbr = c1r - (c1r - c3r) * k;\n cbg = c1g - (c1g - c3g) * k;\n cbb = c1b - (c1b - c3b) * k;\n var x1_ = Math.round(Math.min(xa, xb));\n var x2_ = Math.round(Math.max(xa, xb));\n var j = rowSize * y + x1_ * 4;\n for (var x = x1_; x <= x2_; x++) {\n k = (xa - x) / (xa - xb);\n if (k < 0) {\n k = 0;\n } else if (k > 1) {\n k = 1;\n }\n bytes[j++] = (car - (car - cbr) * k) | 0;\n bytes[j++] = (cag - (cag - cbg) * k) | 0;\n bytes[j++] = (cab - (cab - cbb) * k) | 0;\n bytes[j++] = 255;\n }\n }\n }\n\n function drawFigure(data, figure, context) {\n var ps = figure.coords;\n var cs = figure.colors;\n var i, ii;\n switch (figure.type) {\n case \"lattice\":\n var verticesPerRow = figure.verticesPerRow;\n var rows = Math.floor(ps.length / verticesPerRow) - 1;\n var cols = verticesPerRow - 1;\n for (i = 0; i < rows; i++) {\n var q = i * verticesPerRow;\n for (var j = 0; j < cols; j++, q++) {\n drawTriangle(\n data,\n context,\n ps[q],\n ps[q + 1],\n ps[q + verticesPerRow],\n cs[q],\n cs[q + 1],\n cs[q + verticesPerRow]\n );\n drawTriangle(\n data,\n context,\n ps[q + verticesPerRow + 1],\n ps[q + 1],\n ps[q + verticesPerRow],\n cs[q + verticesPerRow + 1],\n cs[q + 1],\n cs[q + verticesPerRow]\n );\n }\n }\n break;\n case \"triangles\":\n for (i = 0, ii = ps.length; i < ii; i += 3) {\n drawTriangle(\n data,\n context,\n ps[i],\n ps[i + 1],\n ps[i + 2],\n cs[i],\n cs[i + 1],\n cs[i + 2]\n );\n }\n break;\n default:\n throw new Error(\"illegal figure\");\n }\n }\n\n // eslint-disable-next-line no-shadow\n function createMeshCanvas(\n bounds,\n combinesScale,\n coords,\n colors,\n figures,\n backgroundColor,\n cachedCanvases,\n webGLContext\n ) {\n // we will increase scale on some weird factor to let antialiasing take\n // care of \"rough\" edges\n var EXPECTED_SCALE = 1.1;\n // MAX_PATTERN_SIZE is used to avoid OOM situation.\n var MAX_PATTERN_SIZE = 3000; // 10in @ 300dpi shall be enough\n // We need to keep transparent border around our pattern for fill():\n // createPattern with 'no-repeat' will bleed edges across entire area.\n var BORDER_SIZE = 2;\n\n var offsetX = Math.floor(bounds[0]);\n var offsetY = Math.floor(bounds[1]);\n var boundsWidth = Math.ceil(bounds[2]) - offsetX;\n var boundsHeight = Math.ceil(bounds[3]) - offsetY;\n\n var width = Math.min(\n Math.ceil(Math.abs(boundsWidth * combinesScale[0] * EXPECTED_SCALE)),\n MAX_PATTERN_SIZE\n );\n var height = Math.min(\n Math.ceil(Math.abs(boundsHeight * combinesScale[1] * EXPECTED_SCALE)),\n MAX_PATTERN_SIZE\n );\n var scaleX = boundsWidth / width;\n var scaleY = boundsHeight / height;\n\n var context = {\n coords,\n colors,\n offsetX: -offsetX,\n offsetY: -offsetY,\n scaleX: 1 / scaleX,\n scaleY: 1 / scaleY,\n };\n\n var paddedWidth = width + BORDER_SIZE * 2;\n var paddedHeight = height + BORDER_SIZE * 2;\n\n var canvas, tmpCanvas, i, ii;\n if (webGLContext.isEnabled) {\n canvas = webGLContext.drawFigures({\n width,\n height,\n backgroundColor,\n figures,\n context,\n });\n // https://bugzilla.mozilla.org/show_bug.cgi?id=972126\n tmpCanvas = cachedCanvases.getCanvas(\n \"mesh\",\n paddedWidth,\n paddedHeight,\n false\n );\n tmpCanvas.context.drawImage(canvas, BORDER_SIZE, BORDER_SIZE);\n canvas = tmpCanvas.canvas;\n } else {\n tmpCanvas = cachedCanvases.getCanvas(\n \"mesh\",\n paddedWidth,\n paddedHeight,\n false\n );\n var tmpCtx = tmpCanvas.context;\n\n var data = tmpCtx.createImageData(width, height);\n if (backgroundColor) {\n var bytes = data.data;\n for (i = 0, ii = bytes.length; i < ii; i += 4) {\n bytes[i] = backgroundColor[0];\n bytes[i + 1] = backgroundColor[1];\n bytes[i + 2] = backgroundColor[2];\n bytes[i + 3] = 255;\n }\n }\n for (i = 0; i < figures.length; i++) {\n drawFigure(data, figures[i], context);\n }\n tmpCtx.putImageData(data, BORDER_SIZE, BORDER_SIZE);\n canvas = tmpCanvas.canvas;\n }\n\n return {\n canvas,\n offsetX: offsetX - BORDER_SIZE * scaleX,\n offsetY: offsetY - BORDER_SIZE * scaleY,\n scaleX,\n scaleY,\n };\n }\n return createMeshCanvas;\n})();\n\nShadingIRs.Mesh = {\n fromIR: function Mesh_fromIR(raw) {\n // var type = raw[1];\n var coords = raw[2];\n var colors = raw[3];\n var figures = raw[4];\n var bounds = raw[5];\n var matrix = raw[6];\n var bbox = raw[7];\n var background = raw[8];\n return {\n type: \"Pattern\",\n getPattern: function Mesh_getPattern(ctx, owner, shadingFill) {\n applyBoundingBox(ctx, bbox);\n var scale;\n if (shadingFill) {\n scale = Util.singularValueDecompose2dScale(ctx.mozCurrentTransform);\n } else {\n // Obtain scale from matrix and current transformation matrix.\n scale = Util.singularValueDecompose2dScale(owner.baseTransform);\n if (matrix) {\n var matrixScale = Util.singularValueDecompose2dScale(matrix);\n scale = [scale[0] * matrixScale[0], scale[1] * matrixScale[1]];\n }\n }\n\n // Rasterizing on the main thread since sending/queue large canvases\n // might cause OOM.\n var temporaryPatternCanvas = createMeshCanvas(\n bounds,\n scale,\n coords,\n colors,\n figures,\n shadingFill ? null : background,\n owner.cachedCanvases,\n owner.webGLContext\n );\n\n if (!shadingFill) {\n ctx.setTransform.apply(ctx, owner.baseTransform);\n if (matrix) {\n ctx.transform.apply(ctx, matrix);\n }\n }\n\n ctx.translate(\n temporaryPatternCanvas.offsetX,\n temporaryPatternCanvas.offsetY\n );\n ctx.scale(temporaryPatternCanvas.scaleX, temporaryPatternCanvas.scaleY);\n\n return ctx.createPattern(temporaryPatternCanvas.canvas, \"no-repeat\");\n },\n };\n },\n};\n\nShadingIRs.Dummy = {\n fromIR: function Dummy_fromIR() {\n return {\n type: \"Pattern\",\n getPattern: function Dummy_fromIR_getPattern() {\n return \"hotpink\";\n },\n };\n },\n};\n\nfunction getShadingPatternFromIR(raw) {\n var shadingIR = ShadingIRs[raw[0]];\n if (!shadingIR) {\n throw new Error(`Unknown IR type: ${raw[0]}`);\n }\n return shadingIR.fromIR(raw);\n}\n\nvar TilingPattern = (function TilingPatternClosure() {\n var PaintType = {\n COLORED: 1,\n UNCOLORED: 2,\n };\n\n var MAX_PATTERN_SIZE = 3000; // 10in @ 300dpi shall be enough\n\n // eslint-disable-next-line no-shadow\n function TilingPattern(IR, color, ctx, canvasGraphicsFactory, baseTransform) {\n this.operatorList = IR[2];\n this.matrix = IR[3] || [1, 0, 0, 1, 0, 0];\n this.bbox = IR[4];\n this.xstep = IR[5];\n this.ystep = IR[6];\n this.paintType = IR[7];\n this.tilingType = IR[8];\n this.color = color;\n this.canvasGraphicsFactory = canvasGraphicsFactory;\n this.baseTransform = baseTransform;\n this.type = \"Pattern\";\n this.ctx = ctx;\n }\n\n TilingPattern.prototype = {\n createPatternCanvas: function TilinPattern_createPatternCanvas(owner) {\n var operatorList = this.operatorList;\n var bbox = this.bbox;\n var xstep = this.xstep;\n var ystep = this.ystep;\n var paintType = this.paintType;\n var tilingType = this.tilingType;\n var color = this.color;\n var canvasGraphicsFactory = this.canvasGraphicsFactory;\n\n info(\"TilingType: \" + tilingType);\n\n // A tiling pattern as defined by PDF spec 8.7.2 is a cell whose size is\n // described by bbox, and may repeat regularly by shifting the cell by\n // xstep and ystep.\n // Because the HTML5 canvas API does not support pattern repetition with\n // gaps in between, we use the xstep/ystep instead of the bbox's size.\n //\n // This has the following consequences (similarly for ystep):\n //\n // - If xstep is the same as bbox, then there is no observable difference.\n //\n // - If xstep is larger than bbox, then the pattern canvas is partially\n // empty: the area bounded by bbox is painted, the outside area is void.\n //\n // - If xstep is smaller than bbox, then the pixels between xstep and the\n // bbox boundary will be missing. This is INCORRECT behavior.\n // \"Figures on adjacent tiles should not overlap\" (PDF spec 8.7.3.1),\n // but overlapping cells without common pixels are still valid.\n // TODO: Fix the implementation, to allow this scenario to be painted\n // correctly.\n\n var x0 = bbox[0],\n y0 = bbox[1],\n x1 = bbox[2],\n y1 = bbox[3];\n\n // Obtain scale from matrix and current transformation matrix.\n var matrixScale = Util.singularValueDecompose2dScale(this.matrix);\n var curMatrixScale = Util.singularValueDecompose2dScale(\n this.baseTransform\n );\n var combinedScale = [\n matrixScale[0] * curMatrixScale[0],\n matrixScale[1] * curMatrixScale[1],\n ];\n\n // Use width and height values that are as close as possible to the end\n // result when the pattern is used. Too low value makes the pattern look\n // blurry. Too large value makes it look too crispy.\n var dimx = this.getSizeAndScale(\n xstep,\n this.ctx.canvas.width,\n combinedScale[0]\n );\n var dimy = this.getSizeAndScale(\n ystep,\n this.ctx.canvas.height,\n combinedScale[1]\n );\n\n var tmpCanvas = owner.cachedCanvases.getCanvas(\n \"pattern\",\n dimx.size,\n dimy.size,\n true\n );\n var tmpCtx = tmpCanvas.context;\n var graphics = canvasGraphicsFactory.createCanvasGraphics(tmpCtx);\n graphics.groupLevel = owner.groupLevel;\n\n this.setFillAndStrokeStyleToContext(graphics, paintType, color);\n\n graphics.transform(dimx.scale, 0, 0, dimy.scale, 0, 0);\n\n // transform coordinates to pattern space\n graphics.transform(1, 0, 0, 1, -x0, -y0);\n\n this.clipBbox(graphics, bbox, x0, y0, x1, y1);\n\n graphics.executeOperatorList(operatorList);\n\n this.ctx.transform(1, 0, 0, 1, x0, y0);\n\n // Rescale canvas so that the ctx.createPattern call generates a pattern\n // with the desired size.\n this.ctx.scale(1 / dimx.scale, 1 / dimy.scale);\n return tmpCanvas.canvas;\n },\n\n getSizeAndScale: function TilingPattern_getSizeAndScale(\n step,\n realOutputSize,\n scale\n ) {\n // xstep / ystep may be negative -- normalize.\n step = Math.abs(step);\n // MAX_PATTERN_SIZE is used to avoid OOM situation.\n // Use the destination canvas's size if it is bigger than the hard-coded\n // limit of MAX_PATTERN_SIZE to avoid clipping patterns that cover the\n // whole canvas.\n var maxSize = Math.max(MAX_PATTERN_SIZE, realOutputSize);\n var size = Math.ceil(step * scale);\n if (size >= maxSize) {\n size = maxSize;\n } else {\n scale = size / step;\n }\n return { scale, size };\n },\n\n clipBbox: function clipBbox(graphics, bbox, x0, y0, x1, y1) {\n if (Array.isArray(bbox) && bbox.length === 4) {\n var bboxWidth = x1 - x0;\n var bboxHeight = y1 - y0;\n graphics.ctx.rect(x0, y0, bboxWidth, bboxHeight);\n graphics.clip();\n graphics.endPath();\n }\n },\n\n setFillAndStrokeStyleToContext: function setFillAndStrokeStyleToContext(\n graphics,\n paintType,\n color\n ) {\n const context = graphics.ctx,\n current = graphics.current;\n switch (paintType) {\n case PaintType.COLORED:\n var ctx = this.ctx;\n context.fillStyle = ctx.fillStyle;\n context.strokeStyle = ctx.strokeStyle;\n current.fillColor = ctx.fillStyle;\n current.strokeColor = ctx.strokeStyle;\n break;\n case PaintType.UNCOLORED:\n var cssColor = Util.makeCssRgb(color[0], color[1], color[2]);\n context.fillStyle = cssColor;\n context.strokeStyle = cssColor;\n // Set color needed by image masks (fixes issues 3226 and 8741).\n current.fillColor = cssColor;\n current.strokeColor = cssColor;\n break;\n default:\n throw new FormatError(`Unsupported paint type: ${paintType}`);\n }\n },\n\n getPattern: function TilingPattern_getPattern(ctx, owner) {\n ctx = this.ctx;\n // PDF spec 8.7.2 NOTE 1: pattern's matrix is relative to initial matrix.\n ctx.setTransform.apply(ctx, this.baseTransform);\n ctx.transform.apply(ctx, this.matrix);\n\n var temporaryPatternCanvas = this.createPatternCanvas(owner);\n\n return ctx.createPattern(temporaryPatternCanvas, \"repeat\");\n },\n };\n\n return TilingPattern;\n})();\n\nexport { getShadingPatternFromIR, TilingPattern };\n","/* Copyright 2018 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst GlobalWorkerOptions = Object.create(null);\n\n/**\n * Defines global port for worker process. Overrides the `workerSrc` option.\n * @var {Object}\n */\nGlobalWorkerOptions.workerPort =\n GlobalWorkerOptions.workerPort === undefined\n ? null\n : GlobalWorkerOptions.workerPort;\n\n/**\n * A string containing the path and filename of the worker file.\n *\n * NOTE: The `workerSrc` option should always be set, in order to prevent any\n * issues when using the PDF.js library.\n * @var {string}\n */\nGlobalWorkerOptions.workerSrc =\n GlobalWorkerOptions.workerSrc === undefined\n ? \"\"\n : GlobalWorkerOptions.workerSrc;\n\nexport { GlobalWorkerOptions };\n","/* Copyright 2018 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error, prefer-const: error */\n\nimport {\n AbortException,\n assert,\n createPromiseCapability,\n MissingPDFException,\n UnexpectedResponseException,\n UnknownErrorException,\n} from \"./util.js\";\n\nconst CallbackKind = {\n UNKNOWN: 0,\n DATA: 1,\n ERROR: 2,\n};\n\nconst StreamKind = {\n UNKNOWN: 0,\n CANCEL: 1,\n CANCEL_COMPLETE: 2,\n CLOSE: 3,\n ENQUEUE: 4,\n ERROR: 5,\n PULL: 6,\n PULL_COMPLETE: 7,\n START_COMPLETE: 8,\n};\n\nfunction wrapReason(reason) {\n if (\n typeof PDFJSDev === \"undefined\" ||\n PDFJSDev.test(\"!PRODUCTION || TESTING\")\n ) {\n assert(\n reason instanceof Error ||\n (typeof reason === \"object\" && reason !== null),\n 'wrapReason: Expected \"reason\" to be a (possibly cloned) Error.'\n );\n } else {\n if (typeof reason !== \"object\" || reason === null) {\n return reason;\n }\n }\n switch (reason.name) {\n case \"AbortException\":\n return new AbortException(reason.message);\n case \"MissingPDFException\":\n return new MissingPDFException(reason.message);\n case \"UnexpectedResponseException\":\n return new UnexpectedResponseException(reason.message, reason.status);\n case \"UnknownErrorException\":\n return new UnknownErrorException(reason.message, reason.details);\n default:\n return new UnknownErrorException(reason.message, reason.toString());\n }\n}\n\nclass MessageHandler {\n constructor(sourceName, targetName, comObj) {\n this.sourceName = sourceName;\n this.targetName = targetName;\n this.comObj = comObj;\n this.callbackId = 1;\n this.streamId = 1;\n this.postMessageTransfers = true;\n this.streamSinks = Object.create(null);\n this.streamControllers = Object.create(null);\n this.callbackCapabilities = Object.create(null);\n this.actionHandler = Object.create(null);\n\n this._onComObjOnMessage = event => {\n const data = event.data;\n if (data.targetName !== this.sourceName) {\n return;\n }\n if (data.stream) {\n this._processStreamMessage(data);\n return;\n }\n if (data.callback) {\n const callbackId = data.callbackId;\n const capability = this.callbackCapabilities[callbackId];\n if (!capability) {\n throw new Error(`Cannot resolve callback ${callbackId}`);\n }\n delete this.callbackCapabilities[callbackId];\n\n if (data.callback === CallbackKind.DATA) {\n capability.resolve(data.data);\n } else if (data.callback === CallbackKind.ERROR) {\n capability.reject(wrapReason(data.reason));\n } else {\n throw new Error(\"Unexpected callback case\");\n }\n return;\n }\n const action = this.actionHandler[data.action];\n if (!action) {\n throw new Error(`Unknown action from worker: ${data.action}`);\n }\n if (data.callbackId) {\n const cbSourceName = this.sourceName;\n const cbTargetName = data.sourceName;\n new Promise(function (resolve) {\n resolve(action(data.data));\n }).then(\n function (result) {\n comObj.postMessage({\n sourceName: cbSourceName,\n targetName: cbTargetName,\n callback: CallbackKind.DATA,\n callbackId: data.callbackId,\n data: result,\n });\n },\n function (reason) {\n comObj.postMessage({\n sourceName: cbSourceName,\n targetName: cbTargetName,\n callback: CallbackKind.ERROR,\n callbackId: data.callbackId,\n reason: wrapReason(reason),\n });\n }\n );\n return;\n }\n if (data.streamId) {\n this._createStreamSink(data);\n return;\n }\n action(data.data);\n };\n comObj.addEventListener(\"message\", this._onComObjOnMessage);\n }\n\n on(actionName, handler) {\n if (\n typeof PDFJSDev === \"undefined\" ||\n PDFJSDev.test(\"!PRODUCTION || TESTING\")\n ) {\n assert(\n typeof handler === \"function\",\n 'MessageHandler.on: Expected \"handler\" to be a function.'\n );\n }\n const ah = this.actionHandler;\n if (ah[actionName]) {\n throw new Error(`There is already an actionName called \"${actionName}\"`);\n }\n ah[actionName] = handler;\n }\n\n /**\n * Sends a message to the comObj to invoke the action with the supplied data.\n * @param {string} actionName - Action to call.\n * @param {JSON} data - JSON data to send.\n * @param {Array} [transfers] - List of transfers/ArrayBuffers.\n */\n send(actionName, data, transfers) {\n this._postMessage(\n {\n sourceName: this.sourceName,\n targetName: this.targetName,\n action: actionName,\n data,\n },\n transfers\n );\n }\n\n /**\n * Sends a message to the comObj to invoke the action with the supplied data.\n * Expects that the other side will callback with the response.\n * @param {string} actionName - Action to call.\n * @param {JSON} data - JSON data to send.\n * @param {Array} [transfers] - List of transfers/ArrayBuffers.\n * @returns {Promise} Promise to be resolved with response data.\n */\n sendWithPromise(actionName, data, transfers) {\n const callbackId = this.callbackId++;\n const capability = createPromiseCapability();\n this.callbackCapabilities[callbackId] = capability;\n try {\n this._postMessage(\n {\n sourceName: this.sourceName,\n targetName: this.targetName,\n action: actionName,\n callbackId,\n data,\n },\n transfers\n );\n } catch (ex) {\n capability.reject(ex);\n }\n return capability.promise;\n }\n\n /**\n * Sends a message to the comObj to invoke the action with the supplied data.\n * Expect that the other side will callback to signal 'start_complete'.\n * @param {string} actionName - Action to call.\n * @param {JSON} data - JSON data to send.\n * @param {Object} queueingStrategy - Strategy to signal backpressure based on\n * internal queue.\n * @param {Array} [transfers] - List of transfers/ArrayBuffers.\n * @returns {ReadableStream} ReadableStream to read data in chunks.\n */\n sendWithStream(actionName, data, queueingStrategy, transfers) {\n const streamId = this.streamId++;\n const sourceName = this.sourceName;\n const targetName = this.targetName;\n const comObj = this.comObj;\n\n return new ReadableStream(\n {\n start: controller => {\n const startCapability = createPromiseCapability();\n this.streamControllers[streamId] = {\n controller,\n startCall: startCapability,\n pullCall: null,\n cancelCall: null,\n isClosed: false,\n };\n this._postMessage(\n {\n sourceName,\n targetName,\n action: actionName,\n streamId,\n data,\n desiredSize: controller.desiredSize,\n },\n transfers\n );\n // Return Promise for Async process, to signal success/failure.\n return startCapability.promise;\n },\n\n pull: controller => {\n const pullCapability = createPromiseCapability();\n this.streamControllers[streamId].pullCall = pullCapability;\n comObj.postMessage({\n sourceName,\n targetName,\n stream: StreamKind.PULL,\n streamId,\n desiredSize: controller.desiredSize,\n });\n // Returning Promise will not call \"pull\"\n // again until current pull is resolved.\n return pullCapability.promise;\n },\n\n cancel: reason => {\n assert(reason instanceof Error, \"cancel must have a valid reason\");\n const cancelCapability = createPromiseCapability();\n this.streamControllers[streamId].cancelCall = cancelCapability;\n this.streamControllers[streamId].isClosed = true;\n comObj.postMessage({\n sourceName,\n targetName,\n stream: StreamKind.CANCEL,\n streamId,\n reason: wrapReason(reason),\n });\n // Return Promise to signal success or failure.\n return cancelCapability.promise;\n },\n },\n queueingStrategy\n );\n }\n\n /**\n * @private\n */\n _createStreamSink(data) {\n const self = this;\n const action = this.actionHandler[data.action];\n const streamId = data.streamId;\n const sourceName = this.sourceName;\n const targetName = data.sourceName;\n const comObj = this.comObj;\n\n const streamSink = {\n enqueue(chunk, size = 1, transfers) {\n if (this.isCancelled) {\n return;\n }\n const lastDesiredSize = this.desiredSize;\n this.desiredSize -= size;\n // Enqueue decreases the desiredSize property of sink,\n // so when it changes from positive to negative,\n // set ready as unresolved promise.\n if (lastDesiredSize > 0 && this.desiredSize <= 0) {\n this.sinkCapability = createPromiseCapability();\n this.ready = this.sinkCapability.promise;\n }\n self._postMessage(\n {\n sourceName,\n targetName,\n stream: StreamKind.ENQUEUE,\n streamId,\n chunk,\n },\n transfers\n );\n },\n\n close() {\n if (this.isCancelled) {\n return;\n }\n this.isCancelled = true;\n comObj.postMessage({\n sourceName,\n targetName,\n stream: StreamKind.CLOSE,\n streamId,\n });\n delete self.streamSinks[streamId];\n },\n\n error(reason) {\n assert(reason instanceof Error, \"error must have a valid reason\");\n if (this.isCancelled) {\n return;\n }\n this.isCancelled = true;\n comObj.postMessage({\n sourceName,\n targetName,\n stream: StreamKind.ERROR,\n streamId,\n reason: wrapReason(reason),\n });\n },\n\n sinkCapability: createPromiseCapability(),\n onPull: null,\n onCancel: null,\n isCancelled: false,\n desiredSize: data.desiredSize,\n ready: null,\n };\n\n streamSink.sinkCapability.resolve();\n streamSink.ready = streamSink.sinkCapability.promise;\n this.streamSinks[streamId] = streamSink;\n new Promise(function (resolve) {\n resolve(action(data.data, streamSink));\n }).then(\n function () {\n comObj.postMessage({\n sourceName,\n targetName,\n stream: StreamKind.START_COMPLETE,\n streamId,\n success: true,\n });\n },\n function (reason) {\n comObj.postMessage({\n sourceName,\n targetName,\n stream: StreamKind.START_COMPLETE,\n streamId,\n reason: wrapReason(reason),\n });\n }\n );\n }\n\n /**\n * @private\n */\n _processStreamMessage(data) {\n const streamId = data.streamId;\n const sourceName = this.sourceName;\n const targetName = data.sourceName;\n const comObj = this.comObj;\n\n switch (data.stream) {\n case StreamKind.START_COMPLETE:\n if (data.success) {\n this.streamControllers[streamId].startCall.resolve();\n } else {\n this.streamControllers[streamId].startCall.reject(\n wrapReason(data.reason)\n );\n }\n break;\n case StreamKind.PULL_COMPLETE:\n if (data.success) {\n this.streamControllers[streamId].pullCall.resolve();\n } else {\n this.streamControllers[streamId].pullCall.reject(\n wrapReason(data.reason)\n );\n }\n break;\n case StreamKind.PULL:\n // Ignore any pull after close is called.\n if (!this.streamSinks[streamId]) {\n comObj.postMessage({\n sourceName,\n targetName,\n stream: StreamKind.PULL_COMPLETE,\n streamId,\n success: true,\n });\n break;\n }\n // Pull increases the desiredSize property of sink,\n // so when it changes from negative to positive,\n // set ready property as resolved promise.\n if (\n this.streamSinks[streamId].desiredSize <= 0 &&\n data.desiredSize > 0\n ) {\n this.streamSinks[streamId].sinkCapability.resolve();\n }\n // Reset desiredSize property of sink on every pull.\n this.streamSinks[streamId].desiredSize = data.desiredSize;\n const { onPull } = this.streamSinks[data.streamId];\n new Promise(function (resolve) {\n resolve(onPull && onPull());\n }).then(\n function () {\n comObj.postMessage({\n sourceName,\n targetName,\n stream: StreamKind.PULL_COMPLETE,\n streamId,\n success: true,\n });\n },\n function (reason) {\n comObj.postMessage({\n sourceName,\n targetName,\n stream: StreamKind.PULL_COMPLETE,\n streamId,\n reason: wrapReason(reason),\n });\n }\n );\n break;\n case StreamKind.ENQUEUE:\n assert(\n this.streamControllers[streamId],\n \"enqueue should have stream controller\"\n );\n if (this.streamControllers[streamId].isClosed) {\n break;\n }\n this.streamControllers[streamId].controller.enqueue(data.chunk);\n break;\n case StreamKind.CLOSE:\n assert(\n this.streamControllers[streamId],\n \"close should have stream controller\"\n );\n if (this.streamControllers[streamId].isClosed) {\n break;\n }\n this.streamControllers[streamId].isClosed = true;\n this.streamControllers[streamId].controller.close();\n this._deleteStreamController(streamId);\n break;\n case StreamKind.ERROR:\n assert(\n this.streamControllers[streamId],\n \"error should have stream controller\"\n );\n this.streamControllers[streamId].controller.error(\n wrapReason(data.reason)\n );\n this._deleteStreamController(streamId);\n break;\n case StreamKind.CANCEL_COMPLETE:\n if (data.success) {\n this.streamControllers[streamId].cancelCall.resolve();\n } else {\n this.streamControllers[streamId].cancelCall.reject(\n wrapReason(data.reason)\n );\n }\n this._deleteStreamController(streamId);\n break;\n case StreamKind.CANCEL:\n if (!this.streamSinks[streamId]) {\n break;\n }\n const { onCancel } = this.streamSinks[data.streamId];\n new Promise(function (resolve) {\n resolve(onCancel && onCancel(wrapReason(data.reason)));\n }).then(\n function () {\n comObj.postMessage({\n sourceName,\n targetName,\n stream: StreamKind.CANCEL_COMPLETE,\n streamId,\n success: true,\n });\n },\n function (reason) {\n comObj.postMessage({\n sourceName,\n targetName,\n stream: StreamKind.CANCEL_COMPLETE,\n streamId,\n reason: wrapReason(reason),\n });\n }\n );\n this.streamSinks[streamId].sinkCapability.reject(\n wrapReason(data.reason)\n );\n this.streamSinks[streamId].isCancelled = true;\n delete this.streamSinks[streamId];\n break;\n default:\n throw new Error(\"Unexpected stream case\");\n }\n }\n\n /**\n * @private\n */\n async _deleteStreamController(streamId) {\n // Delete the `streamController` only when the start, pull, and cancel\n // capabilities have settled, to prevent `TypeError`s.\n await Promise.allSettled(\n [\n this.streamControllers[streamId].startCall,\n this.streamControllers[streamId].pullCall,\n this.streamControllers[streamId].cancelCall,\n ].map(function (capability) {\n return capability && capability.promise;\n })\n );\n delete this.streamControllers[streamId];\n }\n\n /**\n * Sends raw message to the comObj.\n * @param {Object} message - Raw message.\n * @param transfers List of transfers/ArrayBuffers, or undefined.\n * @private\n */\n _postMessage(message, transfers) {\n if (transfers && this.postMessageTransfers) {\n this.comObj.postMessage(message, transfers);\n } else {\n this.comObj.postMessage(message);\n }\n }\n\n destroy() {\n this.comObj.removeEventListener(\"message\", this._onComObjOnMessage);\n }\n}\n\nexport { MessageHandler };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { assert } from \"../shared/util.js\";\nimport { SimpleXMLParser } from \"./xml_parser.js\";\n\nclass Metadata {\n constructor(data) {\n assert(typeof data === \"string\", \"Metadata: input is not a string\");\n\n // Ghostscript may produce invalid metadata, so try to repair that first.\n data = this._repair(data);\n\n // Convert the string to an XML document.\n const parser = new SimpleXMLParser();\n const xmlDocument = parser.parseFromString(data);\n\n this._metadataMap = new Map();\n\n if (xmlDocument) {\n this._parse(xmlDocument);\n }\n }\n\n _repair(data) {\n // Start by removing any \"junk\" before the first tag (see issue 10395).\n return data\n .replace(/^[^<]+/, \"\")\n .replace(/>\\\\376\\\\377([^<]+)/g, function (all, codes) {\n const bytes = codes\n .replace(/\\\\([0-3])([0-7])([0-7])/g, function (code, d1, d2, d3) {\n return String.fromCharCode(d1 * 64 + d2 * 8 + d3 * 1);\n })\n .replace(/&(amp|apos|gt|lt|quot);/g, function (str, name) {\n switch (name) {\n case \"amp\":\n return \"&\";\n case \"apos\":\n return \"'\";\n case \"gt\":\n return \">\";\n case \"lt\":\n return \"<\";\n case \"quot\":\n return '\"';\n }\n throw new Error(`_repair: ${name} isn't defined.`);\n });\n\n let chars = \"\";\n for (let i = 0, ii = bytes.length; i < ii; i += 2) {\n const code = bytes.charCodeAt(i) * 256 + bytes.charCodeAt(i + 1);\n if (\n code >= /* Space = */ 32 &&\n code < /* Delete = */ 127 &&\n code !== /* '<' = */ 60 &&\n code !== /* '>' = */ 62 &&\n code !== /* '&' = */ 38\n ) {\n chars += String.fromCharCode(code);\n } else {\n chars += \"&#x\" + (0x10000 + code).toString(16).substring(1) + \";\";\n }\n }\n\n return \">\" + chars;\n });\n }\n\n _parse(xmlDocument) {\n let rdf = xmlDocument.documentElement;\n\n if (rdf.nodeName.toLowerCase() !== \"rdf:rdf\") {\n // Wrapped in <xmpmeta>\n rdf = rdf.firstChild;\n while (rdf && rdf.nodeName.toLowerCase() !== \"rdf:rdf\") {\n rdf = rdf.nextSibling;\n }\n }\n\n const nodeName = rdf ? rdf.nodeName.toLowerCase() : null;\n if (!rdf || nodeName !== \"rdf:rdf\" || !rdf.hasChildNodes()) {\n return;\n }\n\n const children = rdf.childNodes;\n for (let i = 0, ii = children.length; i < ii; i++) {\n const desc = children[i];\n if (desc.nodeName.toLowerCase() !== \"rdf:description\") {\n continue;\n }\n\n for (let j = 0, jj = desc.childNodes.length; j < jj; j++) {\n if (desc.childNodes[j].nodeName.toLowerCase() !== \"#text\") {\n const entry = desc.childNodes[j];\n const name = entry.nodeName.toLowerCase();\n\n this._metadataMap.set(name, entry.textContent.trim());\n }\n }\n }\n }\n\n get(name) {\n return this._metadataMap.has(name) ? this._metadataMap.get(name) : null;\n }\n\n getAll() {\n const obj = Object.create(null);\n for (const [key, value] of this._metadataMap) {\n obj[key] = value;\n }\n return obj;\n }\n\n has(name) {\n return this._metadataMap.has(name);\n }\n}\n\nexport { Metadata };\n","/* Copyright 2018 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// The code for XMLParserBase copied from\n// https://github.com/mozilla/shumway/blob/16451d8836fa85f4b16eeda8b4bda2fa9e2b22b0/src/avm2/natives/xml.ts\n\nconst XMLParserErrorCode = {\n NoError: 0,\n EndOfDocument: -1,\n UnterminatedCdat: -2,\n UnterminatedXmlDeclaration: -3,\n UnterminatedDoctypeDeclaration: -4,\n UnterminatedComment: -5,\n MalformedElement: -6,\n OutOfMemory: -7,\n UnterminatedAttributeValue: -8,\n UnterminatedElement: -9,\n ElementNeverBegun: -10,\n};\n\nfunction isWhitespace(s, index) {\n const ch = s[index];\n return ch === \" \" || ch === \"\\n\" || ch === \"\\r\" || ch === \"\\t\";\n}\n\nfunction isWhitespaceString(s) {\n for (let i = 0, ii = s.length; i < ii; i++) {\n if (!isWhitespace(s, i)) {\n return false;\n }\n }\n return true;\n}\n\nclass XMLParserBase {\n _resolveEntities(s) {\n return s.replace(/&([^;]+);/g, (all, entity) => {\n if (entity.substring(0, 2) === \"#x\") {\n return String.fromCharCode(parseInt(entity.substring(2), 16));\n } else if (entity.substring(0, 1) === \"#\") {\n return String.fromCharCode(parseInt(entity.substring(1), 10));\n }\n switch (entity) {\n case \"lt\":\n return \"<\";\n case \"gt\":\n return \">\";\n case \"amp\":\n return \"&\";\n case \"quot\":\n return '\"';\n }\n return this.onResolveEntity(entity);\n });\n }\n\n _parseContent(s, start) {\n const attributes = [];\n let pos = start;\n\n function skipWs() {\n while (pos < s.length && isWhitespace(s, pos)) {\n ++pos;\n }\n }\n\n while (\n pos < s.length &&\n !isWhitespace(s, pos) &&\n s[pos] !== \">\" &&\n s[pos] !== \"/\"\n ) {\n ++pos;\n }\n const name = s.substring(start, pos);\n skipWs();\n while (\n pos < s.length &&\n s[pos] !== \">\" &&\n s[pos] !== \"/\" &&\n s[pos] !== \"?\"\n ) {\n skipWs();\n let attrName = \"\",\n attrValue = \"\";\n while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== \"=\") {\n attrName += s[pos];\n ++pos;\n }\n skipWs();\n if (s[pos] !== \"=\") {\n return null;\n }\n ++pos;\n skipWs();\n const attrEndChar = s[pos];\n if (attrEndChar !== '\"' && attrEndChar !== \"'\") {\n return null;\n }\n const attrEndIndex = s.indexOf(attrEndChar, ++pos);\n if (attrEndIndex < 0) {\n return null;\n }\n attrValue = s.substring(pos, attrEndIndex);\n attributes.push({\n name: attrName,\n value: this._resolveEntities(attrValue),\n });\n pos = attrEndIndex + 1;\n skipWs();\n }\n return {\n name,\n attributes,\n parsed: pos - start,\n };\n }\n\n _parseProcessingInstruction(s, start) {\n let pos = start;\n\n function skipWs() {\n while (pos < s.length && isWhitespace(s, pos)) {\n ++pos;\n }\n }\n\n while (\n pos < s.length &&\n !isWhitespace(s, pos) &&\n s[pos] !== \">\" &&\n s[pos] !== \"/\"\n ) {\n ++pos;\n }\n const name = s.substring(start, pos);\n skipWs();\n const attrStart = pos;\n while (pos < s.length && (s[pos] !== \"?\" || s[pos + 1] !== \">\")) {\n ++pos;\n }\n const value = s.substring(attrStart, pos);\n return {\n name,\n value,\n parsed: pos - start,\n };\n }\n\n parseXml(s) {\n let i = 0;\n while (i < s.length) {\n const ch = s[i];\n let j = i;\n if (ch === \"<\") {\n ++j;\n const ch2 = s[j];\n let q;\n switch (ch2) {\n case \"/\":\n ++j;\n q = s.indexOf(\">\", j);\n if (q < 0) {\n this.onError(XMLParserErrorCode.UnterminatedElement);\n return;\n }\n this.onEndElement(s.substring(j, q));\n j = q + 1;\n break;\n case \"?\":\n ++j;\n const pi = this._parseProcessingInstruction(s, j);\n if (s.substring(j + pi.parsed, j + pi.parsed + 2) !== \"?>\") {\n this.onError(XMLParserErrorCode.UnterminatedXmlDeclaration);\n return;\n }\n this.onPi(pi.name, pi.value);\n j += pi.parsed + 2;\n break;\n case \"!\":\n if (s.substring(j + 1, j + 3) === \"--\") {\n q = s.indexOf(\"-->\", j + 3);\n if (q < 0) {\n this.onError(XMLParserErrorCode.UnterminatedComment);\n return;\n }\n this.onComment(s.substring(j + 3, q));\n j = q + 3;\n } else if (s.substring(j + 1, j + 8) === \"[CDATA[\") {\n q = s.indexOf(\"]]>\", j + 8);\n if (q < 0) {\n this.onError(XMLParserErrorCode.UnterminatedCdat);\n return;\n }\n this.onCdata(s.substring(j + 8, q));\n j = q + 3;\n } else if (s.substring(j + 1, j + 8) === \"DOCTYPE\") {\n const q2 = s.indexOf(\"[\", j + 8);\n let complexDoctype = false;\n q = s.indexOf(\">\", j + 8);\n if (q < 0) {\n this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);\n return;\n }\n if (q2 > 0 && q > q2) {\n q = s.indexOf(\"]>\", j + 8);\n if (q < 0) {\n this.onError(\n XMLParserErrorCode.UnterminatedDoctypeDeclaration\n );\n return;\n }\n complexDoctype = true;\n }\n const doctypeContent = s.substring(\n j + 8,\n q + (complexDoctype ? 1 : 0)\n );\n this.onDoctype(doctypeContent);\n j = q + (complexDoctype ? 2 : 1);\n } else {\n this.onError(XMLParserErrorCode.MalformedElement);\n return;\n }\n break;\n default:\n const content = this._parseContent(s, j);\n if (content === null) {\n this.onError(XMLParserErrorCode.MalformedElement);\n return;\n }\n let isClosed = false;\n if (\n s.substring(j + content.parsed, j + content.parsed + 2) === \"/>\"\n ) {\n isClosed = true;\n } else if (\n s.substring(j + content.parsed, j + content.parsed + 1) !== \">\"\n ) {\n this.onError(XMLParserErrorCode.UnterminatedElement);\n return;\n }\n this.onBeginElement(content.name, content.attributes, isClosed);\n j += content.parsed + (isClosed ? 2 : 1);\n break;\n }\n } else {\n while (j < s.length && s[j] !== \"<\") {\n j++;\n }\n const text = s.substring(i, j);\n this.onText(this._resolveEntities(text));\n }\n i = j;\n }\n }\n\n onResolveEntity(name) {\n return `&${name};`;\n }\n\n onPi(name, value) {}\n\n onComment(text) {}\n\n onCdata(text) {}\n\n onDoctype(doctypeContent) {}\n\n onText(text) {}\n\n onBeginElement(name, attributes, isEmpty) {}\n\n onEndElement(name) {}\n\n onError(code) {}\n}\n\nclass SimpleDOMNode {\n constructor(nodeName, nodeValue) {\n this.nodeName = nodeName;\n this.nodeValue = nodeValue;\n\n Object.defineProperty(this, \"parentNode\", { value: null, writable: true });\n }\n\n get firstChild() {\n return this.childNodes && this.childNodes[0];\n }\n\n get nextSibling() {\n const childNodes = this.parentNode.childNodes;\n if (!childNodes) {\n return undefined;\n }\n const index = childNodes.indexOf(this);\n if (index === -1) {\n return undefined;\n }\n return childNodes[index + 1];\n }\n\n get textContent() {\n if (!this.childNodes) {\n return this.nodeValue || \"\";\n }\n return this.childNodes\n .map(function (child) {\n return child.textContent;\n })\n .join(\"\");\n }\n\n hasChildNodes() {\n return this.childNodes && this.childNodes.length > 0;\n }\n}\n\nclass SimpleXMLParser extends XMLParserBase {\n constructor() {\n super();\n this._currentFragment = null;\n this._stack = null;\n this._errorCode = XMLParserErrorCode.NoError;\n }\n\n parseFromString(data) {\n this._currentFragment = [];\n this._stack = [];\n this._errorCode = XMLParserErrorCode.NoError;\n\n this.parseXml(data);\n\n if (this._errorCode !== XMLParserErrorCode.NoError) {\n return undefined; // return undefined on error\n }\n\n // We should only have one root.\n const [documentElement] = this._currentFragment;\n if (!documentElement) {\n return undefined; // Return undefined if no root was found.\n }\n return { documentElement };\n }\n\n onResolveEntity(name) {\n switch (name) {\n case \"apos\":\n return \"'\";\n }\n return super.onResolveEntity(name);\n }\n\n onText(text) {\n if (isWhitespaceString(text)) {\n return;\n }\n const node = new SimpleDOMNode(\"#text\", text);\n this._currentFragment.push(node);\n }\n\n onCdata(text) {\n const node = new SimpleDOMNode(\"#text\", text);\n this._currentFragment.push(node);\n }\n\n onBeginElement(name, attributes, isEmpty) {\n const node = new SimpleDOMNode(name);\n node.childNodes = [];\n this._currentFragment.push(node);\n if (isEmpty) {\n return;\n }\n this._stack.push(this._currentFragment);\n this._currentFragment = node.childNodes;\n }\n\n onEndElement(name) {\n this._currentFragment = this._stack.pop() || [];\n const lastElement = this._currentFragment[this._currentFragment.length - 1];\n if (!lastElement) {\n return;\n }\n for (let i = 0, ii = lastElement.childNodes.length; i < ii; i++) {\n lastElement.childNodes[i].parentNode = lastElement;\n }\n }\n\n onError(code) {\n this._errorCode = code;\n }\n}\n\nexport { SimpleXMLParser };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error */\n\nimport { assert, createPromiseCapability } from \"../shared/util.js\";\n\n/** @implements {IPDFStream} */\nclass PDFDataTransportStream {\n constructor(params, pdfDataRangeTransport) {\n assert(\n pdfDataRangeTransport,\n 'PDFDataTransportStream - missing required \"pdfDataRangeTransport\" argument.'\n );\n\n this._queuedChunks = [];\n this._progressiveDone = params.progressiveDone || false;\n\n const initialData = params.initialData;\n if (initialData && initialData.length > 0) {\n const buffer = new Uint8Array(initialData).buffer;\n this._queuedChunks.push(buffer);\n }\n\n this._pdfDataRangeTransport = pdfDataRangeTransport;\n this._isStreamingSupported = !params.disableStream;\n this._isRangeSupported = !params.disableRange;\n this._contentLength = params.length;\n\n this._fullRequestReader = null;\n this._rangeReaders = [];\n\n this._pdfDataRangeTransport.addRangeListener((begin, chunk) => {\n this._onReceiveData({ begin, chunk });\n });\n\n this._pdfDataRangeTransport.addProgressListener((loaded, total) => {\n this._onProgress({ loaded, total });\n });\n\n this._pdfDataRangeTransport.addProgressiveReadListener(chunk => {\n this._onReceiveData({ chunk });\n });\n\n this._pdfDataRangeTransport.addProgressiveDoneListener(() => {\n this._onProgressiveDone();\n });\n\n this._pdfDataRangeTransport.transportReady();\n }\n\n _onReceiveData(args) {\n const buffer = new Uint8Array(args.chunk).buffer;\n if (args.begin === undefined) {\n if (this._fullRequestReader) {\n this._fullRequestReader._enqueue(buffer);\n } else {\n this._queuedChunks.push(buffer);\n }\n } else {\n const found = this._rangeReaders.some(function (rangeReader) {\n if (rangeReader._begin !== args.begin) {\n return false;\n }\n rangeReader._enqueue(buffer);\n return true;\n });\n assert(\n found,\n \"_onReceiveData - no `PDFDataTransportStreamRangeReader` instance found.\"\n );\n }\n }\n\n get _progressiveDataLength() {\n return this._fullRequestReader ? this._fullRequestReader._loaded : 0;\n }\n\n _onProgress(evt) {\n if (evt.total === undefined) {\n // Reporting to first range reader, if it exists.\n const firstReader = this._rangeReaders[0];\n if (firstReader && firstReader.onProgress) {\n firstReader.onProgress({ loaded: evt.loaded });\n }\n } else {\n const fullReader = this._fullRequestReader;\n if (fullReader && fullReader.onProgress) {\n fullReader.onProgress({ loaded: evt.loaded, total: evt.total });\n }\n }\n }\n\n _onProgressiveDone() {\n if (this._fullRequestReader) {\n this._fullRequestReader.progressiveDone();\n }\n this._progressiveDone = true;\n }\n\n _removeRangeReader(reader) {\n const i = this._rangeReaders.indexOf(reader);\n if (i >= 0) {\n this._rangeReaders.splice(i, 1);\n }\n }\n\n getFullReader() {\n assert(\n !this._fullRequestReader,\n \"PDFDataTransportStream.getFullReader can only be called once.\"\n );\n const queuedChunks = this._queuedChunks;\n this._queuedChunks = null;\n return new PDFDataTransportStreamReader(\n this,\n queuedChunks,\n this._progressiveDone\n );\n }\n\n getRangeReader(begin, end) {\n if (end <= this._progressiveDataLength) {\n return null;\n }\n const reader = new PDFDataTransportStreamRangeReader(this, begin, end);\n this._pdfDataRangeTransport.requestDataRange(begin, end);\n this._rangeReaders.push(reader);\n return reader;\n }\n\n cancelAllRequests(reason) {\n if (this._fullRequestReader) {\n this._fullRequestReader.cancel(reason);\n }\n const readers = this._rangeReaders.slice(0);\n readers.forEach(function (rangeReader) {\n rangeReader.cancel(reason);\n });\n this._pdfDataRangeTransport.abort();\n }\n}\n\n/** @implements {IPDFStreamReader} */\nclass PDFDataTransportStreamReader {\n constructor(stream, queuedChunks, progressiveDone = false) {\n this._stream = stream;\n this._done = progressiveDone || false;\n this._filename = null;\n this._queuedChunks = queuedChunks || [];\n this._loaded = 0;\n for (const chunk of this._queuedChunks) {\n this._loaded += chunk.byteLength;\n }\n this._requests = [];\n this._headersReady = Promise.resolve();\n stream._fullRequestReader = this;\n\n this.onProgress = null;\n }\n\n _enqueue(chunk) {\n if (this._done) {\n return; // Ignore new data.\n }\n if (this._requests.length > 0) {\n const requestCapability = this._requests.shift();\n requestCapability.resolve({ value: chunk, done: false });\n } else {\n this._queuedChunks.push(chunk);\n }\n this._loaded += chunk.byteLength;\n }\n\n get headersReady() {\n return this._headersReady;\n }\n\n get filename() {\n return this._filename;\n }\n\n get isRangeSupported() {\n return this._stream._isRangeSupported;\n }\n\n get isStreamingSupported() {\n return this._stream._isStreamingSupported;\n }\n\n get contentLength() {\n return this._stream._contentLength;\n }\n\n async read() {\n if (this._queuedChunks.length > 0) {\n const chunk = this._queuedChunks.shift();\n return { value: chunk, done: false };\n }\n if (this._done) {\n return { value: undefined, done: true };\n }\n const requestCapability = createPromiseCapability();\n this._requests.push(requestCapability);\n return requestCapability.promise;\n }\n\n cancel(reason) {\n this._done = true;\n this._requests.forEach(function (requestCapability) {\n requestCapability.resolve({ value: undefined, done: true });\n });\n this._requests = [];\n }\n\n progressiveDone() {\n if (this._done) {\n return;\n }\n this._done = true;\n }\n}\n\n/** @implements {IPDFStreamRangeReader} */\nclass PDFDataTransportStreamRangeReader {\n constructor(stream, begin, end) {\n this._stream = stream;\n this._begin = begin;\n this._end = end;\n this._queuedChunk = null;\n this._requests = [];\n this._done = false;\n\n this.onProgress = null;\n }\n\n _enqueue(chunk) {\n if (this._done) {\n return; // ignore new data\n }\n if (this._requests.length === 0) {\n this._queuedChunk = chunk;\n } else {\n const requestsCapability = this._requests.shift();\n requestsCapability.resolve({ value: chunk, done: false });\n this._requests.forEach(function (requestCapability) {\n requestCapability.resolve({ value: undefined, done: true });\n });\n this._requests = [];\n }\n this._done = true;\n this._stream._removeRangeReader(this);\n }\n\n get isStreamingSupported() {\n return false;\n }\n\n async read() {\n if (this._queuedChunk) {\n const chunk = this._queuedChunk;\n this._queuedChunk = null;\n return { value: chunk, done: false };\n }\n if (this._done) {\n return { value: undefined, done: true };\n }\n const requestCapability = createPromiseCapability();\n this._requests.push(requestCapability);\n return requestCapability.promise;\n }\n\n cancel(reason) {\n this._done = true;\n this._requests.forEach(function (requestCapability) {\n requestCapability.resolve({ value: undefined, done: true });\n });\n this._requests = [];\n this._stream._removeRangeReader(this);\n }\n}\n\nexport { PDFDataTransportStream };\n","/* Copyright 2014 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint-disable no-multi-str */\n\nimport { shadow } from \"../shared/util.js\";\n\nclass WebGLContext {\n constructor({ enable = false }) {\n this._enabled = enable === true;\n }\n\n get isEnabled() {\n let enabled = this._enabled;\n if (enabled) {\n enabled = WebGLUtils.tryInitGL();\n }\n return shadow(this, \"isEnabled\", enabled);\n }\n\n composeSMask({ layer, mask, properties }) {\n return WebGLUtils.composeSMask(layer, mask, properties);\n }\n\n drawFigures({ width, height, backgroundColor, figures, context }) {\n return WebGLUtils.drawFigures(\n width,\n height,\n backgroundColor,\n figures,\n context\n );\n }\n\n clear() {\n WebGLUtils.cleanup();\n }\n}\n\nvar WebGLUtils = (function WebGLUtilsClosure() {\n function loadShader(gl, code, shaderType) {\n var shader = gl.createShader(shaderType);\n gl.shaderSource(shader, code);\n gl.compileShader(shader);\n var compiled = gl.getShaderParameter(shader, gl.COMPILE_STATUS);\n if (!compiled) {\n var errorMsg = gl.getShaderInfoLog(shader);\n throw new Error(\"Error during shader compilation: \" + errorMsg);\n }\n return shader;\n }\n function createVertexShader(gl, code) {\n return loadShader(gl, code, gl.VERTEX_SHADER);\n }\n function createFragmentShader(gl, code) {\n return loadShader(gl, code, gl.FRAGMENT_SHADER);\n }\n function createProgram(gl, shaders) {\n var program = gl.createProgram();\n for (var i = 0, ii = shaders.length; i < ii; ++i) {\n gl.attachShader(program, shaders[i]);\n }\n gl.linkProgram(program);\n var linked = gl.getProgramParameter(program, gl.LINK_STATUS);\n if (!linked) {\n var errorMsg = gl.getProgramInfoLog(program);\n throw new Error(\"Error during program linking: \" + errorMsg);\n }\n return program;\n }\n function createTexture(gl, image, textureId) {\n gl.activeTexture(textureId);\n var texture = gl.createTexture();\n gl.bindTexture(gl.TEXTURE_2D, texture);\n\n // Set the parameters so we can render any size image.\n gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);\n gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);\n gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);\n gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);\n\n // Upload the image into the texture.\n gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);\n return texture;\n }\n\n var currentGL, currentCanvas;\n function generateGL() {\n if (currentGL) {\n return;\n }\n\n // The temporary canvas is used in the WebGL context.\n currentCanvas = document.createElement(\"canvas\");\n currentGL = currentCanvas.getContext(\"webgl\", {\n premultipliedalpha: false,\n });\n }\n\n var smaskVertexShaderCode =\n \"\\\n attribute vec2 a_position; \\\n attribute vec2 a_texCoord; \\\n \\\n uniform vec2 u_resolution; \\\n \\\n varying vec2 v_texCoord; \\\n \\\n void main() { \\\n vec2 clipSpace = (a_position / u_resolution) * 2.0 - 1.0; \\\n gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1); \\\n \\\n v_texCoord = a_texCoord; \\\n } \";\n\n var smaskFragmentShaderCode =\n \"\\\n precision mediump float; \\\n \\\n uniform vec4 u_backdrop; \\\n uniform int u_subtype; \\\n uniform sampler2D u_image; \\\n uniform sampler2D u_mask; \\\n \\\n varying vec2 v_texCoord; \\\n \\\n void main() { \\\n vec4 imageColor = texture2D(u_image, v_texCoord); \\\n vec4 maskColor = texture2D(u_mask, v_texCoord); \\\n if (u_backdrop.a > 0.0) { \\\n maskColor.rgb = maskColor.rgb * maskColor.a + \\\n u_backdrop.rgb * (1.0 - maskColor.a); \\\n } \\\n float lum; \\\n if (u_subtype == 0) { \\\n lum = maskColor.a; \\\n } else { \\\n lum = maskColor.r * 0.3 + maskColor.g * 0.59 + \\\n maskColor.b * 0.11; \\\n } \\\n imageColor.a *= lum; \\\n imageColor.rgb *= imageColor.a; \\\n gl_FragColor = imageColor; \\\n } \";\n\n var smaskCache = null;\n\n function initSmaskGL() {\n var canvas, gl;\n\n generateGL();\n canvas = currentCanvas;\n currentCanvas = null;\n gl = currentGL;\n currentGL = null;\n\n // setup a GLSL program\n var vertexShader = createVertexShader(gl, smaskVertexShaderCode);\n var fragmentShader = createFragmentShader(gl, smaskFragmentShaderCode);\n var program = createProgram(gl, [vertexShader, fragmentShader]);\n gl.useProgram(program);\n\n var cache = {};\n cache.gl = gl;\n cache.canvas = canvas;\n cache.resolutionLocation = gl.getUniformLocation(program, \"u_resolution\");\n cache.positionLocation = gl.getAttribLocation(program, \"a_position\");\n cache.backdropLocation = gl.getUniformLocation(program, \"u_backdrop\");\n cache.subtypeLocation = gl.getUniformLocation(program, \"u_subtype\");\n\n var texCoordLocation = gl.getAttribLocation(program, \"a_texCoord\");\n var texLayerLocation = gl.getUniformLocation(program, \"u_image\");\n var texMaskLocation = gl.getUniformLocation(program, \"u_mask\");\n\n // provide texture coordinates for the rectangle.\n var texCoordBuffer = gl.createBuffer();\n gl.bindBuffer(gl.ARRAY_BUFFER, texCoordBuffer);\n // prettier-ignore\n gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([\n 0.0, 0.0,\n 1.0, 0.0,\n 0.0, 1.0,\n 0.0, 1.0,\n 1.0, 0.0,\n 1.0, 1.0]), gl.STATIC_DRAW);\n gl.enableVertexAttribArray(texCoordLocation);\n gl.vertexAttribPointer(texCoordLocation, 2, gl.FLOAT, false, 0, 0);\n\n gl.uniform1i(texLayerLocation, 0);\n gl.uniform1i(texMaskLocation, 1);\n\n smaskCache = cache;\n }\n\n function composeSMask(layer, mask, properties) {\n var width = layer.width,\n height = layer.height;\n\n if (!smaskCache) {\n initSmaskGL();\n }\n var cache = smaskCache,\n canvas = cache.canvas,\n gl = cache.gl;\n canvas.width = width;\n canvas.height = height;\n gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);\n gl.uniform2f(cache.resolutionLocation, width, height);\n\n if (properties.backdrop) {\n gl.uniform4f(\n cache.resolutionLocation,\n properties.backdrop[0],\n properties.backdrop[1],\n properties.backdrop[2],\n 1\n );\n } else {\n gl.uniform4f(cache.resolutionLocation, 0, 0, 0, 0);\n }\n gl.uniform1i(\n cache.subtypeLocation,\n properties.subtype === \"Luminosity\" ? 1 : 0\n );\n\n // Create a textures\n var texture = createTexture(gl, layer, gl.TEXTURE0);\n var maskTexture = createTexture(gl, mask, gl.TEXTURE1);\n\n // Create a buffer and put a single clipspace rectangle in\n // it (2 triangles)\n var buffer = gl.createBuffer();\n gl.bindBuffer(gl.ARRAY_BUFFER, buffer);\n // prettier-ignore\n gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([\n 0, 0,\n width, 0,\n 0, height,\n 0, height,\n width, 0,\n width, height]), gl.STATIC_DRAW);\n gl.enableVertexAttribArray(cache.positionLocation);\n gl.vertexAttribPointer(cache.positionLocation, 2, gl.FLOAT, false, 0, 0);\n\n // draw\n gl.clearColor(0, 0, 0, 0);\n gl.enable(gl.BLEND);\n gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);\n gl.clear(gl.COLOR_BUFFER_BIT);\n\n gl.drawArrays(gl.TRIANGLES, 0, 6);\n\n gl.flush();\n\n gl.deleteTexture(texture);\n gl.deleteTexture(maskTexture);\n gl.deleteBuffer(buffer);\n\n return canvas;\n }\n\n var figuresVertexShaderCode =\n \"\\\n attribute vec2 a_position; \\\n attribute vec3 a_color; \\\n \\\n uniform vec2 u_resolution; \\\n uniform vec2 u_scale; \\\n uniform vec2 u_offset; \\\n \\\n varying vec4 v_color; \\\n \\\n void main() { \\\n vec2 position = (a_position + u_offset) * u_scale; \\\n vec2 clipSpace = (position / u_resolution) * 2.0 - 1.0; \\\n gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1); \\\n \\\n v_color = vec4(a_color / 255.0, 1.0); \\\n } \";\n\n var figuresFragmentShaderCode =\n \"\\\n precision mediump float; \\\n \\\n varying vec4 v_color; \\\n \\\n void main() { \\\n gl_FragColor = v_color; \\\n } \";\n\n var figuresCache = null;\n\n function initFiguresGL() {\n var canvas, gl;\n\n generateGL();\n canvas = currentCanvas;\n currentCanvas = null;\n gl = currentGL;\n currentGL = null;\n\n // setup a GLSL program\n var vertexShader = createVertexShader(gl, figuresVertexShaderCode);\n var fragmentShader = createFragmentShader(gl, figuresFragmentShaderCode);\n var program = createProgram(gl, [vertexShader, fragmentShader]);\n gl.useProgram(program);\n\n var cache = {};\n cache.gl = gl;\n cache.canvas = canvas;\n cache.resolutionLocation = gl.getUniformLocation(program, \"u_resolution\");\n cache.scaleLocation = gl.getUniformLocation(program, \"u_scale\");\n cache.offsetLocation = gl.getUniformLocation(program, \"u_offset\");\n cache.positionLocation = gl.getAttribLocation(program, \"a_position\");\n cache.colorLocation = gl.getAttribLocation(program, \"a_color\");\n\n figuresCache = cache;\n }\n\n function drawFigures(width, height, backgroundColor, figures, context) {\n if (!figuresCache) {\n initFiguresGL();\n }\n var cache = figuresCache,\n canvas = cache.canvas,\n gl = cache.gl;\n\n canvas.width = width;\n canvas.height = height;\n gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);\n gl.uniform2f(cache.resolutionLocation, width, height);\n\n // count triangle points\n var count = 0;\n var i, ii, rows;\n for (i = 0, ii = figures.length; i < ii; i++) {\n switch (figures[i].type) {\n case \"lattice\":\n rows = (figures[i].coords.length / figures[i].verticesPerRow) | 0;\n count += (rows - 1) * (figures[i].verticesPerRow - 1) * 6;\n break;\n case \"triangles\":\n count += figures[i].coords.length;\n break;\n }\n }\n // transfer data\n var coords = new Float32Array(count * 2);\n var colors = new Uint8Array(count * 3);\n var coordsMap = context.coords,\n colorsMap = context.colors;\n var pIndex = 0,\n cIndex = 0;\n for (i = 0, ii = figures.length; i < ii; i++) {\n var figure = figures[i],\n ps = figure.coords,\n cs = figure.colors;\n switch (figure.type) {\n case \"lattice\":\n var cols = figure.verticesPerRow;\n rows = (ps.length / cols) | 0;\n for (var row = 1; row < rows; row++) {\n var offset = row * cols + 1;\n for (var col = 1; col < cols; col++, offset++) {\n coords[pIndex] = coordsMap[ps[offset - cols - 1]];\n coords[pIndex + 1] = coordsMap[ps[offset - cols - 1] + 1];\n coords[pIndex + 2] = coordsMap[ps[offset - cols]];\n coords[pIndex + 3] = coordsMap[ps[offset - cols] + 1];\n coords[pIndex + 4] = coordsMap[ps[offset - 1]];\n coords[pIndex + 5] = coordsMap[ps[offset - 1] + 1];\n colors[cIndex] = colorsMap[cs[offset - cols - 1]];\n colors[cIndex + 1] = colorsMap[cs[offset - cols - 1] + 1];\n colors[cIndex + 2] = colorsMap[cs[offset - cols - 1] + 2];\n colors[cIndex + 3] = colorsMap[cs[offset - cols]];\n colors[cIndex + 4] = colorsMap[cs[offset - cols] + 1];\n colors[cIndex + 5] = colorsMap[cs[offset - cols] + 2];\n colors[cIndex + 6] = colorsMap[cs[offset - 1]];\n colors[cIndex + 7] = colorsMap[cs[offset - 1] + 1];\n colors[cIndex + 8] = colorsMap[cs[offset - 1] + 2];\n\n coords[pIndex + 6] = coords[pIndex + 2];\n coords[pIndex + 7] = coords[pIndex + 3];\n coords[pIndex + 8] = coords[pIndex + 4];\n coords[pIndex + 9] = coords[pIndex + 5];\n coords[pIndex + 10] = coordsMap[ps[offset]];\n coords[pIndex + 11] = coordsMap[ps[offset] + 1];\n colors[cIndex + 9] = colors[cIndex + 3];\n colors[cIndex + 10] = colors[cIndex + 4];\n colors[cIndex + 11] = colors[cIndex + 5];\n colors[cIndex + 12] = colors[cIndex + 6];\n colors[cIndex + 13] = colors[cIndex + 7];\n colors[cIndex + 14] = colors[cIndex + 8];\n colors[cIndex + 15] = colorsMap[cs[offset]];\n colors[cIndex + 16] = colorsMap[cs[offset] + 1];\n colors[cIndex + 17] = colorsMap[cs[offset] + 2];\n pIndex += 12;\n cIndex += 18;\n }\n }\n break;\n case \"triangles\":\n for (var j = 0, jj = ps.length; j < jj; j++) {\n coords[pIndex] = coordsMap[ps[j]];\n coords[pIndex + 1] = coordsMap[ps[j] + 1];\n colors[cIndex] = colorsMap[cs[j]];\n colors[cIndex + 1] = colorsMap[cs[j] + 1];\n colors[cIndex + 2] = colorsMap[cs[j] + 2];\n pIndex += 2;\n cIndex += 3;\n }\n break;\n }\n }\n\n // draw\n if (backgroundColor) {\n gl.clearColor(\n backgroundColor[0] / 255,\n backgroundColor[1] / 255,\n backgroundColor[2] / 255,\n 1.0\n );\n } else {\n gl.clearColor(0, 0, 0, 0);\n }\n gl.clear(gl.COLOR_BUFFER_BIT);\n\n var coordsBuffer = gl.createBuffer();\n gl.bindBuffer(gl.ARRAY_BUFFER, coordsBuffer);\n gl.bufferData(gl.ARRAY_BUFFER, coords, gl.STATIC_DRAW);\n gl.enableVertexAttribArray(cache.positionLocation);\n gl.vertexAttribPointer(cache.positionLocation, 2, gl.FLOAT, false, 0, 0);\n\n var colorsBuffer = gl.createBuffer();\n gl.bindBuffer(gl.ARRAY_BUFFER, colorsBuffer);\n gl.bufferData(gl.ARRAY_BUFFER, colors, gl.STATIC_DRAW);\n gl.enableVertexAttribArray(cache.colorLocation);\n gl.vertexAttribPointer(\n cache.colorLocation,\n 3,\n gl.UNSIGNED_BYTE,\n false,\n 0,\n 0\n );\n\n gl.uniform2f(cache.scaleLocation, context.scaleX, context.scaleY);\n gl.uniform2f(cache.offsetLocation, context.offsetX, context.offsetY);\n\n gl.drawArrays(gl.TRIANGLES, 0, count);\n\n gl.flush();\n\n gl.deleteBuffer(coordsBuffer);\n gl.deleteBuffer(colorsBuffer);\n\n return canvas;\n }\n\n return {\n tryInitGL() {\n try {\n generateGL();\n return !!currentGL;\n } catch (ex) {}\n return false;\n },\n\n composeSMask,\n\n drawFigures,\n\n cleanup() {\n if (smaskCache && smaskCache.canvas) {\n smaskCache.canvas.width = 0;\n smaskCache.canvas.height = 0;\n }\n if (figuresCache && figuresCache.canvas) {\n figuresCache.canvas.width = 0;\n figuresCache.canvas.height = 0;\n }\n smaskCache = null;\n figuresCache = null;\n },\n };\n})();\n\nexport { WebGLContext };\n","/* Copyright 2014 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error */\n\nimport {\n addLinkAttributes,\n DOMSVGFactory,\n getFilenameFromUrl,\n LinkTarget,\n PDFDateString,\n} from \"./display_utils.js\";\nimport {\n AnnotationBorderStyleType,\n AnnotationType,\n stringToPDFString,\n unreachable,\n Util,\n warn,\n} from \"../shared/util.js\";\n\n/**\n * @typedef {Object} AnnotationElementParameters\n * @property {Object} data\n * @property {HTMLDivElement} layer\n * @property {PDFPage} page\n * @property {PageViewport} viewport\n * @property {IPDFLinkService} linkService\n * @property {DownloadManager} downloadManager\n * @property {string} [imageResourcesPath] - Path for image resources, mainly\n * for annotation icons. Include trailing slash.\n * @property {boolean} renderInteractiveForms\n * @property {Object} svgFactory\n */\n\nclass AnnotationElementFactory {\n /**\n * @param {AnnotationElementParameters} parameters\n * @returns {AnnotationElement}\n */\n static create(parameters) {\n const subtype = parameters.data.annotationType;\n\n switch (subtype) {\n case AnnotationType.LINK:\n return new LinkAnnotationElement(parameters);\n\n case AnnotationType.TEXT:\n return new TextAnnotationElement(parameters);\n\n case AnnotationType.WIDGET:\n const fieldType = parameters.data.fieldType;\n\n switch (fieldType) {\n case \"Tx\":\n return new TextWidgetAnnotationElement(parameters);\n case \"Btn\":\n if (parameters.data.radioButton) {\n return new RadioButtonWidgetAnnotationElement(parameters);\n } else if (parameters.data.checkBox) {\n return new CheckboxWidgetAnnotationElement(parameters);\n }\n return new PushButtonWidgetAnnotationElement(parameters);\n case \"Ch\":\n return new ChoiceWidgetAnnotationElement(parameters);\n }\n return new WidgetAnnotationElement(parameters);\n\n case AnnotationType.POPUP:\n return new PopupAnnotationElement(parameters);\n\n case AnnotationType.FREETEXT:\n return new FreeTextAnnotationElement(parameters);\n\n case AnnotationType.LINE:\n return new LineAnnotationElement(parameters);\n\n case AnnotationType.SQUARE:\n return new SquareAnnotationElement(parameters);\n\n case AnnotationType.CIRCLE:\n return new CircleAnnotationElement(parameters);\n\n case AnnotationType.POLYLINE:\n return new PolylineAnnotationElement(parameters);\n\n case AnnotationType.CARET:\n return new CaretAnnotationElement(parameters);\n\n case AnnotationType.INK:\n return new InkAnnotationElement(parameters);\n\n case AnnotationType.POLYGON:\n return new PolygonAnnotationElement(parameters);\n\n case AnnotationType.HIGHLIGHT:\n return new HighlightAnnotationElement(parameters);\n\n case AnnotationType.UNDERLINE:\n return new UnderlineAnnotationElement(parameters);\n\n case AnnotationType.SQUIGGLY:\n return new SquigglyAnnotationElement(parameters);\n\n case AnnotationType.STRIKEOUT:\n return new StrikeOutAnnotationElement(parameters);\n\n case AnnotationType.STAMP:\n return new StampAnnotationElement(parameters);\n\n case AnnotationType.FILEATTACHMENT:\n return new FileAttachmentAnnotationElement(parameters);\n\n default:\n return new AnnotationElement(parameters);\n }\n }\n}\n\nclass AnnotationElement {\n constructor(parameters, isRenderable = false, ignoreBorder = false) {\n this.isRenderable = isRenderable;\n this.data = parameters.data;\n this.layer = parameters.layer;\n this.page = parameters.page;\n this.viewport = parameters.viewport;\n this.linkService = parameters.linkService;\n this.downloadManager = parameters.downloadManager;\n this.imageResourcesPath = parameters.imageResourcesPath;\n this.renderInteractiveForms = parameters.renderInteractiveForms;\n this.svgFactory = parameters.svgFactory;\n\n if (isRenderable) {\n this.container = this._createContainer(ignoreBorder);\n }\n }\n\n /**\n * Create an empty container for the annotation's HTML element.\n *\n * @private\n * @param {boolean} ignoreBorder\n * @memberof AnnotationElement\n * @returns {HTMLSectionElement}\n */\n _createContainer(ignoreBorder = false) {\n const data = this.data,\n page = this.page,\n viewport = this.viewport;\n const container = document.createElement(\"section\");\n let width = data.rect[2] - data.rect[0];\n let height = data.rect[3] - data.rect[1];\n\n container.setAttribute(\"data-annotation-id\", data.id);\n\n // Do *not* modify `data.rect`, since that will corrupt the annotation\n // position on subsequent calls to `_createContainer` (see issue 6804).\n const rect = Util.normalizeRect([\n data.rect[0],\n page.view[3] - data.rect[1] + page.view[1],\n data.rect[2],\n page.view[3] - data.rect[3] + page.view[1],\n ]);\n\n container.style.transform = `matrix(${viewport.transform.join(\",\")})`;\n container.style.transformOrigin = `-${rect[0]}px -${rect[1]}px`;\n\n if (!ignoreBorder && data.borderStyle.width > 0) {\n container.style.borderWidth = `${data.borderStyle.width}px`;\n if (data.borderStyle.style !== AnnotationBorderStyleType.UNDERLINE) {\n // Underline styles only have a bottom border, so we do not need\n // to adjust for all borders. This yields a similar result as\n // Adobe Acrobat/Reader.\n width = width - 2 * data.borderStyle.width;\n height = height - 2 * data.borderStyle.width;\n }\n\n const horizontalRadius = data.borderStyle.horizontalCornerRadius;\n const verticalRadius = data.borderStyle.verticalCornerRadius;\n if (horizontalRadius > 0 || verticalRadius > 0) {\n const radius = `${horizontalRadius}px / ${verticalRadius}px`;\n container.style.borderRadius = radius;\n }\n\n switch (data.borderStyle.style) {\n case AnnotationBorderStyleType.SOLID:\n container.style.borderStyle = \"solid\";\n break;\n\n case AnnotationBorderStyleType.DASHED:\n container.style.borderStyle = \"dashed\";\n break;\n\n case AnnotationBorderStyleType.BEVELED:\n warn(\"Unimplemented border style: beveled\");\n break;\n\n case AnnotationBorderStyleType.INSET:\n warn(\"Unimplemented border style: inset\");\n break;\n\n case AnnotationBorderStyleType.UNDERLINE:\n container.style.borderBottomStyle = \"solid\";\n break;\n\n default:\n break;\n }\n\n if (data.color) {\n container.style.borderColor = Util.makeCssRgb(\n data.color[0] | 0,\n data.color[1] | 0,\n data.color[2] | 0\n );\n } else {\n // Transparent (invisible) border, so do not draw it at all.\n container.style.borderWidth = 0;\n }\n }\n\n container.style.left = `${rect[0]}px`;\n container.style.top = `${rect[1]}px`;\n container.style.width = `${width}px`;\n container.style.height = `${height}px`;\n return container;\n }\n\n /**\n * Create a popup for the annotation's HTML element. This is used for\n * annotations that do not have a Popup entry in the dictionary, but\n * are of a type that works with popups (such as Highlight annotations).\n *\n * @private\n * @param {HTMLSectionElement} container\n * @param {HTMLDivElement|HTMLImageElement|null} trigger\n * @param {Object} data\n * @memberof AnnotationElement\n */\n _createPopup(container, trigger, data) {\n // If no trigger element is specified, create it.\n if (!trigger) {\n trigger = document.createElement(\"div\");\n trigger.style.height = container.style.height;\n trigger.style.width = container.style.width;\n container.appendChild(trigger);\n }\n\n const popupElement = new PopupElement({\n container,\n trigger,\n color: data.color,\n title: data.title,\n modificationDate: data.modificationDate,\n contents: data.contents,\n hideWrapper: true,\n });\n const popup = popupElement.render();\n\n // Position the popup next to the annotation's container.\n popup.style.left = container.style.width;\n\n container.appendChild(popup);\n }\n\n /**\n * Render the annotation's HTML element in the empty container.\n *\n * @public\n * @memberof AnnotationElement\n */\n render() {\n unreachable(\"Abstract method `AnnotationElement.render` called\");\n }\n}\n\nclass LinkAnnotationElement extends AnnotationElement {\n constructor(parameters) {\n const isRenderable = !!(\n parameters.data.url ||\n parameters.data.dest ||\n parameters.data.action\n );\n super(parameters, isRenderable);\n }\n\n /**\n * Render the link annotation's HTML element in the empty container.\n *\n * @public\n * @memberof LinkAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = \"linkAnnotation\";\n\n const { data, linkService } = this;\n const link = document.createElement(\"a\");\n\n if (data.url) {\n addLinkAttributes(link, {\n url: data.url,\n target: data.newWindow\n ? LinkTarget.BLANK\n : linkService.externalLinkTarget,\n rel: linkService.externalLinkRel,\n enabled: linkService.externalLinkEnabled,\n });\n } else if (data.action) {\n this._bindNamedAction(link, data.action);\n } else {\n this._bindLink(link, data.dest);\n }\n\n this.container.appendChild(link);\n return this.container;\n }\n\n /**\n * Bind internal links to the link element.\n *\n * @private\n * @param {Object} link\n * @param {Object} destination\n * @memberof LinkAnnotationElement\n */\n _bindLink(link, destination) {\n link.href = this.linkService.getDestinationHash(destination);\n link.onclick = () => {\n if (destination) {\n this.linkService.navigateTo(destination);\n }\n return false;\n };\n if (destination) {\n link.className = \"internalLink\";\n }\n }\n\n /**\n * Bind named actions to the link element.\n *\n * @private\n * @param {Object} link\n * @param {Object} action\n * @memberof LinkAnnotationElement\n */\n _bindNamedAction(link, action) {\n link.href = this.linkService.getAnchorUrl(\"\");\n link.onclick = () => {\n this.linkService.executeNamedAction(action);\n return false;\n };\n link.className = \"internalLink\";\n }\n}\n\nclass TextAnnotationElement extends AnnotationElement {\n constructor(parameters) {\n const isRenderable = !!(\n parameters.data.hasPopup ||\n parameters.data.title ||\n parameters.data.contents\n );\n super(parameters, isRenderable);\n }\n\n /**\n * Render the text annotation's HTML element in the empty container.\n *\n * @public\n * @memberof TextAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = \"textAnnotation\";\n\n const image = document.createElement(\"img\");\n image.style.height = this.container.style.height;\n image.style.width = this.container.style.width;\n image.src =\n this.imageResourcesPath +\n \"annotation-\" +\n this.data.name.toLowerCase() +\n \".svg\";\n image.alt = \"[{{type}} Annotation]\";\n image.dataset.l10nId = \"text_annotation_type\";\n image.dataset.l10nArgs = JSON.stringify({ type: this.data.name });\n\n if (!this.data.hasPopup) {\n this._createPopup(this.container, image, this.data);\n }\n\n this.container.appendChild(image);\n return this.container;\n }\n}\n\nclass WidgetAnnotationElement extends AnnotationElement {\n /**\n * Render the widget annotation's HTML element in the empty container.\n *\n * @public\n * @memberof WidgetAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n // Show only the container for unsupported field types.\n return this.container;\n }\n}\n\nclass TextWidgetAnnotationElement extends WidgetAnnotationElement {\n constructor(parameters) {\n const isRenderable =\n parameters.renderInteractiveForms ||\n (!parameters.data.hasAppearance && !!parameters.data.fieldValue);\n super(parameters, isRenderable);\n }\n\n /**\n * Render the text widget annotation's HTML element in the empty container.\n *\n * @public\n * @memberof TextWidgetAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n const TEXT_ALIGNMENT = [\"left\", \"center\", \"right\"];\n\n this.container.className = \"textWidgetAnnotation\";\n\n let element = null;\n if (this.renderInteractiveForms) {\n // NOTE: We cannot set the values using `element.value` below, since it\n // prevents the AnnotationLayer rasterizer in `test/driver.js`\n // from parsing the elements correctly for the reference tests.\n if (this.data.multiLine) {\n element = document.createElement(\"textarea\");\n element.textContent = this.data.fieldValue;\n } else {\n element = document.createElement(\"input\");\n element.type = \"text\";\n element.setAttribute(\"value\", this.data.fieldValue);\n }\n\n element.disabled = this.data.readOnly;\n element.name = this.data.fieldName;\n\n if (this.data.maxLen !== null) {\n element.maxLength = this.data.maxLen;\n }\n\n if (this.data.comb) {\n const fieldWidth = this.data.rect[2] - this.data.rect[0];\n const combWidth = fieldWidth / this.data.maxLen;\n\n element.classList.add(\"comb\");\n element.style.letterSpacing = `calc(${combWidth}px - 1ch)`;\n }\n } else {\n element = document.createElement(\"div\");\n element.textContent = this.data.fieldValue;\n element.style.verticalAlign = \"middle\";\n element.style.display = \"table-cell\";\n\n let font = null;\n if (\n this.data.fontRefName &&\n this.page.commonObjs.has(this.data.fontRefName)\n ) {\n font = this.page.commonObjs.get(this.data.fontRefName);\n }\n this._setTextStyle(element, font);\n }\n\n if (this.data.textAlignment !== null) {\n element.style.textAlign = TEXT_ALIGNMENT[this.data.textAlignment];\n }\n\n this.container.appendChild(element);\n return this.container;\n }\n\n /**\n * Apply text styles to the text in the element.\n *\n * @private\n * @param {HTMLDivElement} element\n * @param {Object} font\n * @memberof TextWidgetAnnotationElement\n */\n _setTextStyle(element, font) {\n // TODO: This duplicates some of the logic in CanvasGraphics.setFont().\n const style = element.style;\n style.fontSize = `${this.data.fontSize}px`;\n style.direction = this.data.fontDirection < 0 ? \"rtl\" : \"ltr\";\n\n if (!font) {\n return;\n }\n\n let bold = \"normal\";\n if (font.black) {\n bold = \"900\";\n } else if (font.bold) {\n bold = \"bold\";\n }\n style.fontWeight = bold;\n style.fontStyle = font.italic ? \"italic\" : \"normal\";\n\n // Use a reasonable default font if the font doesn't specify a fallback.\n const fontFamily = font.loadedName ? `\"${font.loadedName}\", ` : \"\";\n const fallbackName = font.fallbackName || \"Helvetica, sans-serif\";\n style.fontFamily = fontFamily + fallbackName;\n }\n}\n\nclass CheckboxWidgetAnnotationElement extends WidgetAnnotationElement {\n constructor(parameters) {\n super(parameters, parameters.renderInteractiveForms);\n }\n\n /**\n * Render the checkbox widget annotation's HTML element\n * in the empty container.\n *\n * @public\n * @memberof CheckboxWidgetAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = \"buttonWidgetAnnotation checkBox\";\n\n const element = document.createElement(\"input\");\n element.disabled = this.data.readOnly;\n element.type = \"checkbox\";\n element.name = this.data.fieldName;\n if (this.data.fieldValue && this.data.fieldValue !== \"Off\") {\n element.setAttribute(\"checked\", true);\n }\n\n this.container.appendChild(element);\n return this.container;\n }\n}\n\nclass RadioButtonWidgetAnnotationElement extends WidgetAnnotationElement {\n constructor(parameters) {\n super(parameters, parameters.renderInteractiveForms);\n }\n\n /**\n * Render the radio button widget annotation's HTML element\n * in the empty container.\n *\n * @public\n * @memberof RadioButtonWidgetAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = \"buttonWidgetAnnotation radioButton\";\n\n const element = document.createElement(\"input\");\n element.disabled = this.data.readOnly;\n element.type = \"radio\";\n element.name = this.data.fieldName;\n if (this.data.fieldValue === this.data.buttonValue) {\n element.setAttribute(\"checked\", true);\n }\n\n this.container.appendChild(element);\n return this.container;\n }\n}\n\nclass PushButtonWidgetAnnotationElement extends LinkAnnotationElement {\n /**\n * Render the push button widget annotation's HTML element\n * in the empty container.\n *\n * @public\n * @memberof PushButtonWidgetAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n // The rendering and functionality of a push button widget annotation is\n // equal to that of a link annotation, but may have more functionality, such\n // as performing actions on form fields (resetting, submitting, et cetera).\n const container = super.render();\n container.className = \"buttonWidgetAnnotation pushButton\";\n return container;\n }\n}\n\nclass ChoiceWidgetAnnotationElement extends WidgetAnnotationElement {\n constructor(parameters) {\n super(parameters, parameters.renderInteractiveForms);\n }\n\n /**\n * Render the choice widget annotation's HTML element in the empty\n * container.\n *\n * @public\n * @memberof ChoiceWidgetAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = \"choiceWidgetAnnotation\";\n\n const selectElement = document.createElement(\"select\");\n selectElement.disabled = this.data.readOnly;\n selectElement.name = this.data.fieldName;\n\n if (!this.data.combo) {\n // List boxes have a size and (optionally) multiple selection.\n selectElement.size = this.data.options.length;\n if (this.data.multiSelect) {\n selectElement.multiple = true;\n }\n }\n\n // Insert the options into the choice field.\n for (const option of this.data.options) {\n const optionElement = document.createElement(\"option\");\n optionElement.textContent = option.displayValue;\n optionElement.value = option.exportValue;\n if (this.data.fieldValue.includes(option.displayValue)) {\n optionElement.setAttribute(\"selected\", true);\n }\n selectElement.appendChild(optionElement);\n }\n\n this.container.appendChild(selectElement);\n return this.container;\n }\n}\n\nclass PopupAnnotationElement extends AnnotationElement {\n constructor(parameters) {\n const isRenderable = !!(parameters.data.title || parameters.data.contents);\n super(parameters, isRenderable);\n }\n\n /**\n * Render the popup annotation's HTML element in the empty container.\n *\n * @public\n * @memberof PopupAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n // Do not render popup annotations for parent elements with these types as\n // they create the popups themselves (because of custom trigger divs).\n const IGNORE_TYPES = [\n \"Line\",\n \"Square\",\n \"Circle\",\n \"PolyLine\",\n \"Polygon\",\n \"Ink\",\n ];\n\n this.container.className = \"popupAnnotation\";\n\n if (IGNORE_TYPES.includes(this.data.parentType)) {\n return this.container;\n }\n\n const selector = `[data-annotation-id=\"${this.data.parentId}\"]`;\n const parentElement = this.layer.querySelector(selector);\n if (!parentElement) {\n return this.container;\n }\n\n const popup = new PopupElement({\n container: this.container,\n trigger: parentElement,\n color: this.data.color,\n title: this.data.title,\n modificationDate: this.data.modificationDate,\n contents: this.data.contents,\n });\n\n // Position the popup next to the parent annotation's container.\n // PDF viewers ignore a popup annotation's rectangle.\n const parentLeft = parseFloat(parentElement.style.left);\n const parentWidth = parseFloat(parentElement.style.width);\n this.container.style.transformOrigin = `-${parentLeft + parentWidth}px -${\n parentElement.style.top\n }`;\n this.container.style.left = `${parentLeft + parentWidth}px`;\n\n this.container.appendChild(popup.render());\n return this.container;\n }\n}\n\nclass PopupElement {\n constructor(parameters) {\n this.container = parameters.container;\n this.trigger = parameters.trigger;\n this.color = parameters.color;\n this.title = parameters.title;\n this.modificationDate = parameters.modificationDate;\n this.contents = parameters.contents;\n this.hideWrapper = parameters.hideWrapper || false;\n\n this.pinned = false;\n }\n\n /**\n * Render the popup's HTML element.\n *\n * @public\n * @memberof PopupElement\n * @returns {HTMLSectionElement}\n */\n render() {\n const BACKGROUND_ENLIGHT = 0.7;\n\n const wrapper = document.createElement(\"div\");\n wrapper.className = \"popupWrapper\";\n\n // For Popup annotations we hide the entire section because it contains\n // only the popup. However, for Text annotations without a separate Popup\n // annotation, we cannot hide the entire container as the image would\n // disappear too. In that special case, hiding the wrapper suffices.\n this.hideElement = this.hideWrapper ? wrapper : this.container;\n this.hideElement.setAttribute(\"hidden\", true);\n\n const popup = document.createElement(\"div\");\n popup.className = \"popup\";\n\n const color = this.color;\n if (color) {\n // Enlighten the color.\n const r = BACKGROUND_ENLIGHT * (255 - color[0]) + color[0];\n const g = BACKGROUND_ENLIGHT * (255 - color[1]) + color[1];\n const b = BACKGROUND_ENLIGHT * (255 - color[2]) + color[2];\n popup.style.backgroundColor = Util.makeCssRgb(r | 0, g | 0, b | 0);\n }\n\n const title = document.createElement(\"h1\");\n title.textContent = this.title;\n popup.appendChild(title);\n\n // The modification date is shown in the popup instead of the creation\n // date if it is available and can be parsed correctly, which is\n // consistent with other viewers such as Adobe Acrobat.\n const dateObject = PDFDateString.toDateObject(this.modificationDate);\n if (dateObject) {\n const modificationDate = document.createElement(\"span\");\n modificationDate.textContent = \"{{date}}, {{time}}\";\n modificationDate.dataset.l10nId = \"annotation_date_string\";\n modificationDate.dataset.l10nArgs = JSON.stringify({\n date: dateObject.toLocaleDateString(),\n time: dateObject.toLocaleTimeString(),\n });\n popup.appendChild(modificationDate);\n }\n\n const contents = this._formatContents(this.contents);\n popup.appendChild(contents);\n\n // Attach the event listeners to the trigger element.\n this.trigger.addEventListener(\"click\", this._toggle.bind(this));\n this.trigger.addEventListener(\"mouseover\", this._show.bind(this, false));\n this.trigger.addEventListener(\"mouseout\", this._hide.bind(this, false));\n popup.addEventListener(\"click\", this._hide.bind(this, true));\n\n wrapper.appendChild(popup);\n return wrapper;\n }\n\n /**\n * Format the contents of the popup by adding newlines where necessary.\n *\n * @private\n * @param {string} contents\n * @memberof PopupElement\n * @returns {HTMLParagraphElement}\n */\n _formatContents(contents) {\n const p = document.createElement(\"p\");\n const lines = contents.split(/(?:\\r\\n?|\\n)/);\n for (let i = 0, ii = lines.length; i < ii; ++i) {\n const line = lines[i];\n p.appendChild(document.createTextNode(line));\n if (i < ii - 1) {\n p.appendChild(document.createElement(\"br\"));\n }\n }\n return p;\n }\n\n /**\n * Toggle the visibility of the popup.\n *\n * @private\n * @memberof PopupElement\n */\n _toggle() {\n if (this.pinned) {\n this._hide(true);\n } else {\n this._show(true);\n }\n }\n\n /**\n * Show the popup.\n *\n * @private\n * @param {boolean} pin\n * @memberof PopupElement\n */\n _show(pin = false) {\n if (pin) {\n this.pinned = true;\n }\n if (this.hideElement.hasAttribute(\"hidden\")) {\n this.hideElement.removeAttribute(\"hidden\");\n this.container.style.zIndex += 1;\n }\n }\n\n /**\n * Hide the popup.\n *\n * @private\n * @param {boolean} unpin\n * @memberof PopupElement\n */\n _hide(unpin = true) {\n if (unpin) {\n this.pinned = false;\n }\n if (!this.hideElement.hasAttribute(\"hidden\") && !this.pinned) {\n this.hideElement.setAttribute(\"hidden\", true);\n this.container.style.zIndex -= 1;\n }\n }\n}\n\nclass FreeTextAnnotationElement extends AnnotationElement {\n constructor(parameters) {\n const isRenderable = !!(\n parameters.data.hasPopup ||\n parameters.data.title ||\n parameters.data.contents\n );\n super(parameters, isRenderable, /* ignoreBorder = */ true);\n }\n\n /**\n * Render the free text annotation's HTML element in the empty container.\n *\n * @public\n * @memberof FreeTextAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = \"freeTextAnnotation\";\n\n if (!this.data.hasPopup) {\n this._createPopup(this.container, null, this.data);\n }\n return this.container;\n }\n}\n\nclass LineAnnotationElement extends AnnotationElement {\n constructor(parameters) {\n const isRenderable = !!(\n parameters.data.hasPopup ||\n parameters.data.title ||\n parameters.data.contents\n );\n super(parameters, isRenderable, /* ignoreBorder = */ true);\n }\n\n /**\n * Render the line annotation's HTML element in the empty container.\n *\n * @public\n * @memberof LineAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = \"lineAnnotation\";\n\n // Create an invisible line with the same starting and ending coordinates\n // that acts as the trigger for the popup. Only the line itself should\n // trigger the popup, not the entire container.\n const data = this.data;\n const width = data.rect[2] - data.rect[0];\n const height = data.rect[3] - data.rect[1];\n const svg = this.svgFactory.create(width, height);\n\n // PDF coordinates are calculated from a bottom left origin, so transform\n // the line coordinates to a top left origin for the SVG element.\n const line = this.svgFactory.createElement(\"svg:line\");\n line.setAttribute(\"x1\", data.rect[2] - data.lineCoordinates[0]);\n line.setAttribute(\"y1\", data.rect[3] - data.lineCoordinates[1]);\n line.setAttribute(\"x2\", data.rect[2] - data.lineCoordinates[2]);\n line.setAttribute(\"y2\", data.rect[3] - data.lineCoordinates[3]);\n // Ensure that the 'stroke-width' is always non-zero, since otherwise it\n // won't be possible to open/close the popup (note e.g. issue 11122).\n line.setAttribute(\"stroke-width\", data.borderStyle.width || 1);\n line.setAttribute(\"stroke\", \"transparent\");\n\n svg.appendChild(line);\n this.container.append(svg);\n\n // Create the popup ourselves so that we can bind it to the line instead\n // of to the entire container (which is the default).\n this._createPopup(this.container, line, data);\n\n return this.container;\n }\n}\n\nclass SquareAnnotationElement extends AnnotationElement {\n constructor(parameters) {\n const isRenderable = !!(\n parameters.data.hasPopup ||\n parameters.data.title ||\n parameters.data.contents\n );\n super(parameters, isRenderable, /* ignoreBorder = */ true);\n }\n\n /**\n * Render the square annotation's HTML element in the empty container.\n *\n * @public\n * @memberof SquareAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = \"squareAnnotation\";\n\n // Create an invisible square with the same rectangle that acts as the\n // trigger for the popup. Only the square itself should trigger the\n // popup, not the entire container.\n const data = this.data;\n const width = data.rect[2] - data.rect[0];\n const height = data.rect[3] - data.rect[1];\n const svg = this.svgFactory.create(width, height);\n\n // The browser draws half of the borders inside the square and half of\n // the borders outside the square by default. This behavior cannot be\n // changed programmatically, so correct for that here.\n const borderWidth = data.borderStyle.width;\n const square = this.svgFactory.createElement(\"svg:rect\");\n square.setAttribute(\"x\", borderWidth / 2);\n square.setAttribute(\"y\", borderWidth / 2);\n square.setAttribute(\"width\", width - borderWidth);\n square.setAttribute(\"height\", height - borderWidth);\n // Ensure that the 'stroke-width' is always non-zero, since otherwise it\n // won't be possible to open/close the popup (note e.g. issue 11122).\n square.setAttribute(\"stroke-width\", borderWidth || 1);\n square.setAttribute(\"stroke\", \"transparent\");\n square.setAttribute(\"fill\", \"none\");\n\n svg.appendChild(square);\n this.container.append(svg);\n\n // Create the popup ourselves so that we can bind it to the square instead\n // of to the entire container (which is the default).\n this._createPopup(this.container, square, data);\n\n return this.container;\n }\n}\n\nclass CircleAnnotationElement extends AnnotationElement {\n constructor(parameters) {\n const isRenderable = !!(\n parameters.data.hasPopup ||\n parameters.data.title ||\n parameters.data.contents\n );\n super(parameters, isRenderable, /* ignoreBorder = */ true);\n }\n\n /**\n * Render the circle annotation's HTML element in the empty container.\n *\n * @public\n * @memberof CircleAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = \"circleAnnotation\";\n\n // Create an invisible circle with the same ellipse that acts as the\n // trigger for the popup. Only the circle itself should trigger the\n // popup, not the entire container.\n const data = this.data;\n const width = data.rect[2] - data.rect[0];\n const height = data.rect[3] - data.rect[1];\n const svg = this.svgFactory.create(width, height);\n\n // The browser draws half of the borders inside the circle and half of\n // the borders outside the circle by default. This behavior cannot be\n // changed programmatically, so correct for that here.\n const borderWidth = data.borderStyle.width;\n const circle = this.svgFactory.createElement(\"svg:ellipse\");\n circle.setAttribute(\"cx\", width / 2);\n circle.setAttribute(\"cy\", height / 2);\n circle.setAttribute(\"rx\", width / 2 - borderWidth / 2);\n circle.setAttribute(\"ry\", height / 2 - borderWidth / 2);\n // Ensure that the 'stroke-width' is always non-zero, since otherwise it\n // won't be possible to open/close the popup (note e.g. issue 11122).\n circle.setAttribute(\"stroke-width\", borderWidth || 1);\n circle.setAttribute(\"stroke\", \"transparent\");\n circle.setAttribute(\"fill\", \"none\");\n\n svg.appendChild(circle);\n this.container.append(svg);\n\n // Create the popup ourselves so that we can bind it to the circle instead\n // of to the entire container (which is the default).\n this._createPopup(this.container, circle, data);\n\n return this.container;\n }\n}\n\nclass PolylineAnnotationElement extends AnnotationElement {\n constructor(parameters) {\n const isRenderable = !!(\n parameters.data.hasPopup ||\n parameters.data.title ||\n parameters.data.contents\n );\n super(parameters, isRenderable, /* ignoreBorder = */ true);\n\n this.containerClassName = \"polylineAnnotation\";\n this.svgElementName = \"svg:polyline\";\n }\n\n /**\n * Render the polyline annotation's HTML element in the empty container.\n *\n * @public\n * @memberof PolylineAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = this.containerClassName;\n\n // Create an invisible polyline with the same points that acts as the\n // trigger for the popup. Only the polyline itself should trigger the\n // popup, not the entire container.\n const data = this.data;\n const width = data.rect[2] - data.rect[0];\n const height = data.rect[3] - data.rect[1];\n const svg = this.svgFactory.create(width, height);\n\n // Convert the vertices array to a single points string that the SVG\n // polyline element expects (\"x1,y1 x2,y2 ...\"). PDF coordinates are\n // calculated from a bottom left origin, so transform the polyline\n // coordinates to a top left origin for the SVG element.\n let points = [];\n for (const coordinate of data.vertices) {\n const x = coordinate.x - data.rect[0];\n const y = data.rect[3] - coordinate.y;\n points.push(x + \",\" + y);\n }\n points = points.join(\" \");\n\n const polyline = this.svgFactory.createElement(this.svgElementName);\n polyline.setAttribute(\"points\", points);\n // Ensure that the 'stroke-width' is always non-zero, since otherwise it\n // won't be possible to open/close the popup (note e.g. issue 11122).\n polyline.setAttribute(\"stroke-width\", data.borderStyle.width || 1);\n polyline.setAttribute(\"stroke\", \"transparent\");\n polyline.setAttribute(\"fill\", \"none\");\n\n svg.appendChild(polyline);\n this.container.append(svg);\n\n // Create the popup ourselves so that we can bind it to the polyline\n // instead of to the entire container (which is the default).\n this._createPopup(this.container, polyline, data);\n\n return this.container;\n }\n}\n\nclass PolygonAnnotationElement extends PolylineAnnotationElement {\n constructor(parameters) {\n // Polygons are specific forms of polylines, so reuse their logic.\n super(parameters);\n\n this.containerClassName = \"polygonAnnotation\";\n this.svgElementName = \"svg:polygon\";\n }\n}\n\nclass CaretAnnotationElement extends AnnotationElement {\n constructor(parameters) {\n const isRenderable = !!(\n parameters.data.hasPopup ||\n parameters.data.title ||\n parameters.data.contents\n );\n super(parameters, isRenderable, /* ignoreBorder = */ true);\n }\n\n /**\n * Render the caret annotation's HTML element in the empty container.\n *\n * @public\n * @memberof CaretAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = \"caretAnnotation\";\n\n if (!this.data.hasPopup) {\n this._createPopup(this.container, null, this.data);\n }\n return this.container;\n }\n}\n\nclass InkAnnotationElement extends AnnotationElement {\n constructor(parameters) {\n const isRenderable = !!(\n parameters.data.hasPopup ||\n parameters.data.title ||\n parameters.data.contents\n );\n super(parameters, isRenderable, /* ignoreBorder = */ true);\n\n this.containerClassName = \"inkAnnotation\";\n\n // Use the polyline SVG element since it allows us to use coordinates\n // directly and to draw both straight lines and curves.\n this.svgElementName = \"svg:polyline\";\n }\n\n /**\n * Render the ink annotation's HTML element in the empty container.\n *\n * @public\n * @memberof InkAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = this.containerClassName;\n\n // Create an invisible polyline with the same points that acts as the\n // trigger for the popup.\n const data = this.data;\n const width = data.rect[2] - data.rect[0];\n const height = data.rect[3] - data.rect[1];\n const svg = this.svgFactory.create(width, height);\n\n for (const inkList of data.inkLists) {\n // Convert the ink list to a single points string that the SVG\n // polyline element expects (\"x1,y1 x2,y2 ...\"). PDF coordinates are\n // calculated from a bottom left origin, so transform the polyline\n // coordinates to a top left origin for the SVG element.\n let points = [];\n for (const coordinate of inkList) {\n const x = coordinate.x - data.rect[0];\n const y = data.rect[3] - coordinate.y;\n points.push(`${x},${y}`);\n }\n points = points.join(\" \");\n\n const polyline = this.svgFactory.createElement(this.svgElementName);\n polyline.setAttribute(\"points\", points);\n // Ensure that the 'stroke-width' is always non-zero, since otherwise it\n // won't be possible to open/close the popup (note e.g. issue 11122).\n polyline.setAttribute(\"stroke-width\", data.borderStyle.width || 1);\n polyline.setAttribute(\"stroke\", \"transparent\");\n polyline.setAttribute(\"fill\", \"none\");\n\n // Create the popup ourselves so that we can bind it to the polyline\n // instead of to the entire container (which is the default).\n this._createPopup(this.container, polyline, data);\n\n svg.appendChild(polyline);\n }\n\n this.container.append(svg);\n return this.container;\n }\n}\n\nclass HighlightAnnotationElement extends AnnotationElement {\n constructor(parameters) {\n const isRenderable = !!(\n parameters.data.hasPopup ||\n parameters.data.title ||\n parameters.data.contents\n );\n super(parameters, isRenderable, /* ignoreBorder = */ true);\n }\n\n /**\n * Render the highlight annotation's HTML element in the empty container.\n *\n * @public\n * @memberof HighlightAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = \"highlightAnnotation\";\n\n if (!this.data.hasPopup) {\n this._createPopup(this.container, null, this.data);\n }\n return this.container;\n }\n}\n\nclass UnderlineAnnotationElement extends AnnotationElement {\n constructor(parameters) {\n const isRenderable = !!(\n parameters.data.hasPopup ||\n parameters.data.title ||\n parameters.data.contents\n );\n super(parameters, isRenderable, /* ignoreBorder = */ true);\n }\n\n /**\n * Render the underline annotation's HTML element in the empty container.\n *\n * @public\n * @memberof UnderlineAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = \"underlineAnnotation\";\n\n if (!this.data.hasPopup) {\n this._createPopup(this.container, null, this.data);\n }\n return this.container;\n }\n}\n\nclass SquigglyAnnotationElement extends AnnotationElement {\n constructor(parameters) {\n const isRenderable = !!(\n parameters.data.hasPopup ||\n parameters.data.title ||\n parameters.data.contents\n );\n super(parameters, isRenderable, /* ignoreBorder = */ true);\n }\n\n /**\n * Render the squiggly annotation's HTML element in the empty container.\n *\n * @public\n * @memberof SquigglyAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = \"squigglyAnnotation\";\n\n if (!this.data.hasPopup) {\n this._createPopup(this.container, null, this.data);\n }\n return this.container;\n }\n}\n\nclass StrikeOutAnnotationElement extends AnnotationElement {\n constructor(parameters) {\n const isRenderable = !!(\n parameters.data.hasPopup ||\n parameters.data.title ||\n parameters.data.contents\n );\n super(parameters, isRenderable, /* ignoreBorder = */ true);\n }\n\n /**\n * Render the strikeout annotation's HTML element in the empty container.\n *\n * @public\n * @memberof StrikeOutAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = \"strikeoutAnnotation\";\n\n if (!this.data.hasPopup) {\n this._createPopup(this.container, null, this.data);\n }\n return this.container;\n }\n}\n\nclass StampAnnotationElement extends AnnotationElement {\n constructor(parameters) {\n const isRenderable = !!(\n parameters.data.hasPopup ||\n parameters.data.title ||\n parameters.data.contents\n );\n super(parameters, isRenderable, /* ignoreBorder = */ true);\n }\n\n /**\n * Render the stamp annotation's HTML element in the empty container.\n *\n * @public\n * @memberof StampAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = \"stampAnnotation\";\n\n if (!this.data.hasPopup) {\n this._createPopup(this.container, null, this.data);\n }\n return this.container;\n }\n}\n\nclass FileAttachmentAnnotationElement extends AnnotationElement {\n constructor(parameters) {\n super(parameters, /* isRenderable = */ true);\n\n const { filename, content } = this.data.file;\n this.filename = getFilenameFromUrl(filename);\n this.content = content;\n\n if (this.linkService.eventBus) {\n this.linkService.eventBus.dispatch(\"fileattachmentannotation\", {\n source: this,\n id: stringToPDFString(filename),\n filename,\n content,\n });\n }\n }\n\n /**\n * Render the file attachment annotation's HTML element in the empty\n * container.\n *\n * @public\n * @memberof FileAttachmentAnnotationElement\n * @returns {HTMLSectionElement}\n */\n render() {\n this.container.className = \"fileAttachmentAnnotation\";\n\n const trigger = document.createElement(\"div\");\n trigger.style.height = this.container.style.height;\n trigger.style.width = this.container.style.width;\n trigger.addEventListener(\"dblclick\", this._download.bind(this));\n\n if (!this.data.hasPopup && (this.data.title || this.data.contents)) {\n this._createPopup(this.container, trigger, this.data);\n }\n\n this.container.appendChild(trigger);\n return this.container;\n }\n\n /**\n * Download the file attachment associated with this annotation.\n *\n * @private\n * @memberof FileAttachmentAnnotationElement\n */\n _download() {\n if (!this.downloadManager) {\n warn(\"Download cannot be started due to unavailable download manager\");\n return;\n }\n this.downloadManager.downloadData(this.content, this.filename, \"\");\n }\n}\n\n/**\n * @typedef {Object} AnnotationLayerParameters\n * @property {PageViewport} viewport\n * @property {HTMLDivElement} div\n * @property {Array} annotations\n * @property {PDFPage} page\n * @property {IPDFLinkService} linkService\n * @property {DownloadManager} downloadManager\n * @property {string} [imageResourcesPath] - Path for image resources, mainly\n * for annotation icons. Include trailing slash.\n * @property {boolean} renderInteractiveForms\n */\n\nclass AnnotationLayer {\n /**\n * Render a new annotation layer with all annotation elements.\n *\n * @public\n * @param {AnnotationLayerParameters} parameters\n * @memberof AnnotationLayer\n */\n static render(parameters) {\n const sortedAnnotations = [],\n popupAnnotations = [];\n // Ensure that Popup annotations are handled last, since they're dependant\n // upon the parent annotation having already been rendered (please refer to\n // the `PopupAnnotationElement.render` method); fixes issue 11362.\n for (const data of parameters.annotations) {\n if (!data) {\n continue;\n }\n if (data.annotationType === AnnotationType.POPUP) {\n popupAnnotations.push(data);\n continue;\n }\n sortedAnnotations.push(data);\n }\n if (popupAnnotations.length) {\n sortedAnnotations.push(...popupAnnotations);\n }\n\n for (const data of sortedAnnotations) {\n const element = AnnotationElementFactory.create({\n data,\n layer: parameters.div,\n page: parameters.page,\n viewport: parameters.viewport,\n linkService: parameters.linkService,\n downloadManager: parameters.downloadManager,\n imageResourcesPath: parameters.imageResourcesPath || \"\",\n renderInteractiveForms: parameters.renderInteractiveForms || false,\n svgFactory: new DOMSVGFactory(),\n });\n if (element.isRenderable) {\n parameters.div.appendChild(element.render());\n }\n }\n }\n\n /**\n * Update the annotation elements on existing annotation layer.\n *\n * @public\n * @param {AnnotationLayerParameters} parameters\n * @memberof AnnotationLayer\n */\n static update(parameters) {\n for (const data of parameters.annotations) {\n const element = parameters.div.querySelector(\n `[data-annotation-id=\"${data.id}\"]`\n );\n if (element) {\n element.style.transform = `matrix(${parameters.viewport.transform.join(\n \",\"\n )})`;\n }\n }\n parameters.div.removeAttribute(\"hidden\");\n }\n}\n\nexport { AnnotationLayer };\n","/* Copyright 2015 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n AbortException,\n createPromiseCapability,\n Util,\n} from \"../shared/util.js\";\n\n/**\n * Text layer render parameters.\n *\n * @typedef {Object} TextLayerRenderParameters\n * @property {TextContent} [textContent] - Text content to render (the object\n * is returned by the page's `getTextContent` method).\n * @property {ReadableStream} [textContentStream] - Text content stream to\n * render (the stream is returned by the page's `streamTextContent` method).\n * @property {HTMLElement} container - HTML element that will contain text runs.\n * @property {PageViewport} viewport - The target viewport to properly\n * layout the text runs.\n * @property {Array} [textDivs] - HTML elements that are correspond to the\n * text items of the textContent input. This is output and shall be\n * initially be set to empty array.\n * @property {Array} [textContentItemsStr] - Strings that correspond to the\n * `str` property of the text items of textContent input. This is output\n * and shall be initially be set to empty array.\n * @property {number} [timeout] - Delay in milliseconds before rendering of the\n * text runs occurs.\n * @property {boolean} [enhanceTextSelection] - Whether to turn on the text\n * selection enhancement.\n */\nvar renderTextLayer = (function renderTextLayerClosure() {\n var MAX_TEXT_DIVS_TO_RENDER = 100000;\n\n var NonWhitespaceRegexp = /\\S/;\n\n function isAllWhitespace(str) {\n return !NonWhitespaceRegexp.test(str);\n }\n\n function appendText(task, geom, styles) {\n // Initialize all used properties to keep the caches monomorphic.\n var textDiv = document.createElement(\"span\");\n var textDivProperties = {\n angle: 0,\n canvasWidth: 0,\n isWhitespace: false,\n originalTransform: null,\n paddingBottom: 0,\n paddingLeft: 0,\n paddingRight: 0,\n paddingTop: 0,\n scale: 1,\n };\n\n task._textDivs.push(textDiv);\n if (isAllWhitespace(geom.str)) {\n textDivProperties.isWhitespace = true;\n task._textDivProperties.set(textDiv, textDivProperties);\n return;\n }\n\n var tx = Util.transform(task._viewport.transform, geom.transform);\n var angle = Math.atan2(tx[1], tx[0]);\n var style = styles[geom.fontName];\n if (style.vertical) {\n angle += Math.PI / 2;\n }\n var fontHeight = Math.sqrt(tx[2] * tx[2] + tx[3] * tx[3]);\n var fontAscent = fontHeight;\n if (style.ascent) {\n fontAscent = style.ascent * fontAscent;\n } else if (style.descent) {\n fontAscent = (1 + style.descent) * fontAscent;\n }\n\n let left, top;\n if (angle === 0) {\n left = tx[4];\n top = tx[5] - fontAscent;\n } else {\n left = tx[4] + fontAscent * Math.sin(angle);\n top = tx[5] - fontAscent * Math.cos(angle);\n }\n // Setting the style properties individually, rather than all at once,\n // should be OK since the `textDiv` isn't appended to the document yet.\n textDiv.style.left = `${left}px`;\n textDiv.style.top = `${top}px`;\n textDiv.style.fontSize = `${fontHeight}px`;\n textDiv.style.fontFamily = style.fontFamily;\n\n textDiv.textContent = geom.str;\n // `fontName` is only used by the FontInspector, and we only use `dataset`\n // here to make the font name available in the debugger.\n if (task._fontInspectorEnabled) {\n textDiv.dataset.fontName = geom.fontName;\n }\n if (angle !== 0) {\n textDivProperties.angle = angle * (180 / Math.PI);\n }\n // We don't bother scaling single-char text divs, because it has very\n // little effect on text highlighting. This makes scrolling on docs with\n // lots of such divs a lot faster.\n let shouldScaleText = false;\n if (geom.str.length > 1) {\n shouldScaleText = true;\n } else if (geom.transform[0] !== geom.transform[3]) {\n const absScaleX = Math.abs(geom.transform[0]),\n absScaleY = Math.abs(geom.transform[3]);\n // When the horizontal/vertical scaling differs significantly, also scale\n // even single-char text to improve highlighting (fixes issue11713.pdf).\n if (\n absScaleX !== absScaleY &&\n Math.max(absScaleX, absScaleY) / Math.min(absScaleX, absScaleY) > 1.5\n ) {\n shouldScaleText = true;\n }\n }\n if (shouldScaleText) {\n if (style.vertical) {\n textDivProperties.canvasWidth = geom.height * task._viewport.scale;\n } else {\n textDivProperties.canvasWidth = geom.width * task._viewport.scale;\n }\n }\n task._textDivProperties.set(textDiv, textDivProperties);\n if (task._textContentStream) {\n task._layoutText(textDiv);\n }\n\n if (task._enhanceTextSelection) {\n var angleCos = 1,\n angleSin = 0;\n if (angle !== 0) {\n angleCos = Math.cos(angle);\n angleSin = Math.sin(angle);\n }\n var divWidth =\n (style.vertical ? geom.height : geom.width) * task._viewport.scale;\n var divHeight = fontHeight;\n\n var m, b;\n if (angle !== 0) {\n m = [angleCos, angleSin, -angleSin, angleCos, left, top];\n b = Util.getAxialAlignedBoundingBox([0, 0, divWidth, divHeight], m);\n } else {\n b = [left, top, left + divWidth, top + divHeight];\n }\n\n task._bounds.push({\n left: b[0],\n top: b[1],\n right: b[2],\n bottom: b[3],\n div: textDiv,\n size: [divWidth, divHeight],\n m,\n });\n }\n }\n\n function render(task) {\n if (task._canceled) {\n return;\n }\n var textDivs = task._textDivs;\n var capability = task._capability;\n var textDivsLength = textDivs.length;\n\n // No point in rendering many divs as it would make the browser\n // unusable even after the divs are rendered.\n if (textDivsLength > MAX_TEXT_DIVS_TO_RENDER) {\n task._renderingDone = true;\n capability.resolve();\n return;\n }\n\n if (!task._textContentStream) {\n for (var i = 0; i < textDivsLength; i++) {\n task._layoutText(textDivs[i]);\n }\n }\n\n task._renderingDone = true;\n capability.resolve();\n }\n\n function findPositiveMin(ts, offset, count) {\n let result = 0;\n for (let i = 0; i < count; i++) {\n const t = ts[offset++];\n if (t > 0) {\n result = result ? Math.min(t, result) : t;\n }\n }\n return result;\n }\n\n function expand(task) {\n var bounds = task._bounds;\n var viewport = task._viewport;\n\n var expanded = expandBounds(viewport.width, viewport.height, bounds);\n for (var i = 0; i < expanded.length; i++) {\n var div = bounds[i].div;\n var divProperties = task._textDivProperties.get(div);\n if (divProperties.angle === 0) {\n divProperties.paddingLeft = bounds[i].left - expanded[i].left;\n divProperties.paddingTop = bounds[i].top - expanded[i].top;\n divProperties.paddingRight = expanded[i].right - bounds[i].right;\n divProperties.paddingBottom = expanded[i].bottom - bounds[i].bottom;\n task._textDivProperties.set(div, divProperties);\n continue;\n }\n // Box is rotated -- trying to find padding so rotated div will not\n // exceed its expanded bounds.\n var e = expanded[i],\n b = bounds[i];\n var m = b.m,\n c = m[0],\n s = m[1];\n // Finding intersections with expanded box.\n var points = [[0, 0], [0, b.size[1]], [b.size[0], 0], b.size];\n var ts = new Float64Array(64);\n points.forEach(function (p, j) {\n var t = Util.applyTransform(p, m);\n ts[j + 0] = c && (e.left - t[0]) / c;\n ts[j + 4] = s && (e.top - t[1]) / s;\n ts[j + 8] = c && (e.right - t[0]) / c;\n ts[j + 12] = s && (e.bottom - t[1]) / s;\n\n ts[j + 16] = s && (e.left - t[0]) / -s;\n ts[j + 20] = c && (e.top - t[1]) / c;\n ts[j + 24] = s && (e.right - t[0]) / -s;\n ts[j + 28] = c && (e.bottom - t[1]) / c;\n\n ts[j + 32] = c && (e.left - t[0]) / -c;\n ts[j + 36] = s && (e.top - t[1]) / -s;\n ts[j + 40] = c && (e.right - t[0]) / -c;\n ts[j + 44] = s && (e.bottom - t[1]) / -s;\n\n ts[j + 48] = s && (e.left - t[0]) / s;\n ts[j + 52] = c && (e.top - t[1]) / -c;\n ts[j + 56] = s && (e.right - t[0]) / s;\n ts[j + 60] = c && (e.bottom - t[1]) / -c;\n });\n // Not based on math, but to simplify calculations, using cos and sin\n // absolute values to not exceed the box (it can but insignificantly).\n var boxScale = 1 + Math.min(Math.abs(c), Math.abs(s));\n divProperties.paddingLeft = findPositiveMin(ts, 32, 16) / boxScale;\n divProperties.paddingTop = findPositiveMin(ts, 48, 16) / boxScale;\n divProperties.paddingRight = findPositiveMin(ts, 0, 16) / boxScale;\n divProperties.paddingBottom = findPositiveMin(ts, 16, 16) / boxScale;\n task._textDivProperties.set(div, divProperties);\n }\n }\n\n function expandBounds(width, height, boxes) {\n var bounds = boxes.map(function (box, i) {\n return {\n x1: box.left,\n y1: box.top,\n x2: box.right,\n y2: box.bottom,\n index: i,\n x1New: undefined,\n x2New: undefined,\n };\n });\n expandBoundsLTR(width, bounds);\n var expanded = new Array(boxes.length);\n bounds.forEach(function (b) {\n var i = b.index;\n expanded[i] = {\n left: b.x1New,\n top: 0,\n right: b.x2New,\n bottom: 0,\n };\n });\n\n // Rotating on 90 degrees and extending extended boxes. Reusing the bounds\n // array and objects.\n boxes.map(function (box, i) {\n var e = expanded[i],\n b = bounds[i];\n b.x1 = box.top;\n b.y1 = width - e.right;\n b.x2 = box.bottom;\n b.y2 = width - e.left;\n b.index = i;\n b.x1New = undefined;\n b.x2New = undefined;\n });\n expandBoundsLTR(height, bounds);\n\n bounds.forEach(function (b) {\n var i = b.index;\n expanded[i].top = b.x1New;\n expanded[i].bottom = b.x2New;\n });\n return expanded;\n }\n\n function expandBoundsLTR(width, bounds) {\n // Sorting by x1 coordinate and walk by the bounds in the same order.\n bounds.sort(function (a, b) {\n return a.x1 - b.x1 || a.index - b.index;\n });\n\n // First we see on the horizon is a fake boundary.\n var fakeBoundary = {\n x1: -Infinity,\n y1: -Infinity,\n x2: 0,\n y2: Infinity,\n index: -1,\n x1New: 0,\n x2New: 0,\n };\n var horizon = [\n {\n start: -Infinity,\n end: Infinity,\n boundary: fakeBoundary,\n },\n ];\n\n bounds.forEach(function (boundary) {\n // Searching for the affected part of horizon.\n // TODO red-black tree or simple binary search\n var i = 0;\n while (i < horizon.length && horizon[i].end <= boundary.y1) {\n i++;\n }\n var j = horizon.length - 1;\n while (j >= 0 && horizon[j].start >= boundary.y2) {\n j--;\n }\n\n var horizonPart, affectedBoundary;\n var q,\n k,\n maxXNew = -Infinity;\n for (q = i; q <= j; q++) {\n horizonPart = horizon[q];\n affectedBoundary = horizonPart.boundary;\n var xNew;\n if (affectedBoundary.x2 > boundary.x1) {\n // In the middle of the previous element, new x shall be at the\n // boundary start. Extending if further if the affected boundary\n // placed on top of the current one.\n xNew =\n affectedBoundary.index > boundary.index\n ? affectedBoundary.x1New\n : boundary.x1;\n } else if (affectedBoundary.x2New === undefined) {\n // We have some space in between, new x in middle will be a fair\n // choice.\n xNew = (affectedBoundary.x2 + boundary.x1) / 2;\n } else {\n // Affected boundary has x2new set, using it as new x.\n xNew = affectedBoundary.x2New;\n }\n if (xNew > maxXNew) {\n maxXNew = xNew;\n }\n }\n\n // Set new x1 for current boundary.\n boundary.x1New = maxXNew;\n\n // Adjusts new x2 for the affected boundaries.\n for (q = i; q <= j; q++) {\n horizonPart = horizon[q];\n affectedBoundary = horizonPart.boundary;\n if (affectedBoundary.x2New === undefined) {\n // Was not set yet, choosing new x if possible.\n if (affectedBoundary.x2 > boundary.x1) {\n // Current and affected boundaries intersect. If affected boundary\n // is placed on top of the current, shrinking the affected.\n if (affectedBoundary.index > boundary.index) {\n affectedBoundary.x2New = affectedBoundary.x2;\n }\n } else {\n affectedBoundary.x2New = maxXNew;\n }\n } else if (affectedBoundary.x2New > maxXNew) {\n // Affected boundary is touching new x, pushing it back.\n affectedBoundary.x2New = Math.max(maxXNew, affectedBoundary.x2);\n }\n }\n\n // Fixing the horizon.\n var changedHorizon = [],\n lastBoundary = null;\n for (q = i; q <= j; q++) {\n horizonPart = horizon[q];\n affectedBoundary = horizonPart.boundary;\n // Checking which boundary will be visible.\n var useBoundary =\n affectedBoundary.x2 > boundary.x2 ? affectedBoundary : boundary;\n if (lastBoundary === useBoundary) {\n // Merging with previous.\n changedHorizon[changedHorizon.length - 1].end = horizonPart.end;\n } else {\n changedHorizon.push({\n start: horizonPart.start,\n end: horizonPart.end,\n boundary: useBoundary,\n });\n lastBoundary = useBoundary;\n }\n }\n if (horizon[i].start < boundary.y1) {\n changedHorizon[0].start = boundary.y1;\n changedHorizon.unshift({\n start: horizon[i].start,\n end: boundary.y1,\n boundary: horizon[i].boundary,\n });\n }\n if (boundary.y2 < horizon[j].end) {\n changedHorizon[changedHorizon.length - 1].end = boundary.y2;\n changedHorizon.push({\n start: boundary.y2,\n end: horizon[j].end,\n boundary: horizon[j].boundary,\n });\n }\n\n // Set x2 new of boundary that is no longer visible (see overlapping case\n // above).\n // TODO more efficient, e.g. via reference counting.\n for (q = i; q <= j; q++) {\n horizonPart = horizon[q];\n affectedBoundary = horizonPart.boundary;\n if (affectedBoundary.x2New !== undefined) {\n continue;\n }\n var used = false;\n for (\n k = i - 1;\n !used && k >= 0 && horizon[k].start >= affectedBoundary.y1;\n k--\n ) {\n used = horizon[k].boundary === affectedBoundary;\n }\n for (\n k = j + 1;\n !used && k < horizon.length && horizon[k].end <= affectedBoundary.y2;\n k++\n ) {\n used = horizon[k].boundary === affectedBoundary;\n }\n for (k = 0; !used && k < changedHorizon.length; k++) {\n used = changedHorizon[k].boundary === affectedBoundary;\n }\n if (!used) {\n affectedBoundary.x2New = maxXNew;\n }\n }\n\n Array.prototype.splice.apply(\n horizon,\n [i, j - i + 1].concat(changedHorizon)\n );\n });\n\n // Set new x2 for all unset boundaries.\n horizon.forEach(function (horizonPart) {\n var affectedBoundary = horizonPart.boundary;\n if (affectedBoundary.x2New === undefined) {\n affectedBoundary.x2New = Math.max(width, affectedBoundary.x2);\n }\n });\n }\n\n /**\n * Text layer rendering task.\n *\n * @param {TextContent} textContent\n * @param {HTMLElement} container\n * @param {PageViewport} viewport\n * @param {Array} textDivs\n * @param {boolean} enhanceTextSelection\n * @private\n */\n function TextLayerRenderTask({\n textContent,\n textContentStream,\n container,\n viewport,\n textDivs,\n textContentItemsStr,\n enhanceTextSelection,\n }) {\n this._textContent = textContent;\n this._textContentStream = textContentStream;\n this._container = container;\n this._viewport = viewport;\n this._textDivs = textDivs || [];\n this._textContentItemsStr = textContentItemsStr || [];\n this._enhanceTextSelection = !!enhanceTextSelection;\n this._fontInspectorEnabled = !!(\n globalThis.FontInspector && globalThis.FontInspector.enabled\n );\n\n this._reader = null;\n this._layoutTextLastFontSize = null;\n this._layoutTextLastFontFamily = null;\n this._layoutTextCtx = null;\n this._textDivProperties = new WeakMap();\n this._renderingDone = false;\n this._canceled = false;\n this._capability = createPromiseCapability();\n this._renderTimer = null;\n this._bounds = [];\n\n // Always clean-up the temporary canvas once rendering is no longer pending.\n this._capability.promise\n .finally(() => {\n if (this._layoutTextCtx) {\n // Zeroing the width and height cause Firefox to release graphics\n // resources immediately, which can greatly reduce memory consumption.\n this._layoutTextCtx.canvas.width = 0;\n this._layoutTextCtx.canvas.height = 0;\n this._layoutTextCtx = null;\n }\n })\n .catch(() => {\n /* Avoid \"Uncaught promise\" messages in the console. */\n });\n }\n TextLayerRenderTask.prototype = {\n get promise() {\n return this._capability.promise;\n },\n\n cancel: function TextLayer_cancel() {\n this._canceled = true;\n if (this._reader) {\n this._reader.cancel(new AbortException(\"TextLayer task cancelled.\"));\n this._reader = null;\n }\n if (this._renderTimer !== null) {\n clearTimeout(this._renderTimer);\n this._renderTimer = null;\n }\n this._capability.reject(new Error(\"TextLayer task cancelled.\"));\n },\n\n _processItems(items, styleCache) {\n for (let i = 0, len = items.length; i < len; i++) {\n this._textContentItemsStr.push(items[i].str);\n appendText(this, items[i], styleCache);\n }\n },\n\n _layoutText(textDiv) {\n const textDivProperties = this._textDivProperties.get(textDiv);\n if (textDivProperties.isWhitespace) {\n return;\n }\n\n let transform = \"\";\n if (textDivProperties.canvasWidth !== 0) {\n const { fontSize, fontFamily } = textDiv.style;\n\n // Only build font string and set to context if different from last.\n if (\n fontSize !== this._layoutTextLastFontSize ||\n fontFamily !== this._layoutTextLastFontFamily\n ) {\n this._layoutTextCtx.font = `${fontSize} ${fontFamily}`;\n this._layoutTextLastFontSize = fontSize;\n this._layoutTextLastFontFamily = fontFamily;\n }\n // Only measure the width for multi-char text divs, see `appendText`.\n const { width } = this._layoutTextCtx.measureText(textDiv.textContent);\n\n if (width > 0) {\n textDivProperties.scale = textDivProperties.canvasWidth / width;\n transform = `scaleX(${textDivProperties.scale})`;\n }\n }\n if (textDivProperties.angle !== 0) {\n transform = `rotate(${textDivProperties.angle}deg) ${transform}`;\n }\n if (transform.length > 0) {\n if (this._enhanceTextSelection) {\n textDivProperties.originalTransform = transform;\n }\n textDiv.style.transform = transform;\n }\n this._textDivProperties.set(textDiv, textDivProperties);\n this._container.appendChild(textDiv);\n },\n\n _render: function TextLayer_render(timeout) {\n const capability = createPromiseCapability();\n let styleCache = Object.create(null);\n\n // The temporary canvas is used to measure text length in the DOM.\n const canvas = document.createElement(\"canvas\");\n if (\n typeof PDFJSDev === \"undefined\" ||\n PDFJSDev.test(\"MOZCENTRAL || GENERIC\")\n ) {\n canvas.mozOpaque = true;\n }\n this._layoutTextCtx = canvas.getContext(\"2d\", { alpha: false });\n\n if (this._textContent) {\n const textItems = this._textContent.items;\n const textStyles = this._textContent.styles;\n this._processItems(textItems, textStyles);\n capability.resolve();\n } else if (this._textContentStream) {\n const pump = () => {\n this._reader.read().then(({ value, done }) => {\n if (done) {\n capability.resolve();\n return;\n }\n\n Object.assign(styleCache, value.styles);\n this._processItems(value.items, styleCache);\n pump();\n }, capability.reject);\n };\n\n this._reader = this._textContentStream.getReader();\n pump();\n } else {\n throw new Error(\n 'Neither \"textContent\" nor \"textContentStream\"' +\n \" parameters specified.\"\n );\n }\n\n capability.promise.then(() => {\n styleCache = null;\n if (!timeout) {\n // Render right away\n render(this);\n } else {\n // Schedule\n this._renderTimer = setTimeout(() => {\n render(this);\n this._renderTimer = null;\n }, timeout);\n }\n }, this._capability.reject);\n },\n\n expandTextDivs: function TextLayer_expandTextDivs(expandDivs) {\n if (!this._enhanceTextSelection || !this._renderingDone) {\n return;\n }\n if (this._bounds !== null) {\n expand(this);\n this._bounds = null;\n }\n const transformBuf = [],\n paddingBuf = [];\n\n for (var i = 0, ii = this._textDivs.length; i < ii; i++) {\n const div = this._textDivs[i];\n const divProps = this._textDivProperties.get(div);\n\n if (divProps.isWhitespace) {\n continue;\n }\n if (expandDivs) {\n transformBuf.length = 0;\n paddingBuf.length = 0;\n\n if (divProps.originalTransform) {\n transformBuf.push(divProps.originalTransform);\n }\n if (divProps.paddingTop > 0) {\n paddingBuf.push(`${divProps.paddingTop}px`);\n transformBuf.push(`translateY(${-divProps.paddingTop}px)`);\n } else {\n paddingBuf.push(0);\n }\n if (divProps.paddingRight > 0) {\n paddingBuf.push(`${divProps.paddingRight / divProps.scale}px`);\n } else {\n paddingBuf.push(0);\n }\n if (divProps.paddingBottom > 0) {\n paddingBuf.push(`${divProps.paddingBottom}px`);\n } else {\n paddingBuf.push(0);\n }\n if (divProps.paddingLeft > 0) {\n paddingBuf.push(`${divProps.paddingLeft / divProps.scale}px`);\n transformBuf.push(\n `translateX(${-divProps.paddingLeft / divProps.scale}px)`\n );\n } else {\n paddingBuf.push(0);\n }\n\n div.style.padding = paddingBuf.join(\" \");\n if (transformBuf.length) {\n div.style.transform = transformBuf.join(\" \");\n }\n } else {\n div.style.padding = null;\n div.style.transform = divProps.originalTransform;\n }\n }\n },\n };\n\n /**\n * Starts rendering of the text layer.\n *\n * @param {TextLayerRenderParameters} renderParameters\n * @returns {TextLayerRenderTask}\n */\n // eslint-disable-next-line no-shadow\n function renderTextLayer(renderParameters) {\n var task = new TextLayerRenderTask({\n textContent: renderParameters.textContent,\n textContentStream: renderParameters.textContentStream,\n container: renderParameters.container,\n viewport: renderParameters.viewport,\n textDivs: renderParameters.textDivs,\n textContentItemsStr: renderParameters.textContentItemsStr,\n enhanceTextSelection: renderParameters.enhanceTextSelection,\n });\n task._render(renderParameters.timeout);\n return task;\n }\n\n return renderTextLayer;\n})();\n\nexport { renderTextLayer };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* globals __non_webpack_require__ */\n/* eslint no-var: error */\n\nimport {\n createObjectURL,\n FONT_IDENTITY_MATRIX,\n IDENTITY_MATRIX,\n ImageKind,\n isNum,\n OPS,\n TextRenderingMode,\n Util,\n warn,\n} from \"../shared/util.js\";\nimport { DOMSVGFactory } from \"./display_utils.js\";\nimport { isNodeJS } from \"../shared/is_node.js\";\n\nlet SVGGraphics = function () {\n throw new Error(\"Not implemented: SVGGraphics\");\n};\n\nif (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) {\n const SVG_DEFAULTS = {\n fontStyle: \"normal\",\n fontWeight: \"normal\",\n fillColor: \"#000000\",\n };\n const XML_NS = \"http://www.w3.org/XML/1998/namespace\";\n const XLINK_NS = \"http://www.w3.org/1999/xlink\";\n const LINE_CAP_STYLES = [\"butt\", \"round\", \"square\"];\n const LINE_JOIN_STYLES = [\"miter\", \"round\", \"bevel\"];\n\n const convertImgDataToPng = (function () {\n const PNG_HEADER = new Uint8Array([\n 0x89,\n 0x50,\n 0x4e,\n 0x47,\n 0x0d,\n 0x0a,\n 0x1a,\n 0x0a,\n ]);\n const CHUNK_WRAPPER_SIZE = 12;\n\n const crcTable = new Int32Array(256);\n for (let i = 0; i < 256; i++) {\n let c = i;\n for (let h = 0; h < 8; h++) {\n if (c & 1) {\n c = 0xedb88320 ^ ((c >> 1) & 0x7fffffff);\n } else {\n c = (c >> 1) & 0x7fffffff;\n }\n }\n crcTable[i] = c;\n }\n\n function crc32(data, start, end) {\n let crc = -1;\n for (let i = start; i < end; i++) {\n const a = (crc ^ data[i]) & 0xff;\n const b = crcTable[a];\n crc = (crc >>> 8) ^ b;\n }\n return crc ^ -1;\n }\n\n function writePngChunk(type, body, data, offset) {\n let p = offset;\n const len = body.length;\n\n data[p] = (len >> 24) & 0xff;\n data[p + 1] = (len >> 16) & 0xff;\n data[p + 2] = (len >> 8) & 0xff;\n data[p + 3] = len & 0xff;\n p += 4;\n\n data[p] = type.charCodeAt(0) & 0xff;\n data[p + 1] = type.charCodeAt(1) & 0xff;\n data[p + 2] = type.charCodeAt(2) & 0xff;\n data[p + 3] = type.charCodeAt(3) & 0xff;\n p += 4;\n\n data.set(body, p);\n p += body.length;\n\n const crc = crc32(data, offset + 4, p);\n data[p] = (crc >> 24) & 0xff;\n data[p + 1] = (crc >> 16) & 0xff;\n data[p + 2] = (crc >> 8) & 0xff;\n data[p + 3] = crc & 0xff;\n }\n\n function adler32(data, start, end) {\n let a = 1;\n let b = 0;\n for (let i = start; i < end; ++i) {\n a = (a + (data[i] & 0xff)) % 65521;\n b = (b + a) % 65521;\n }\n return (b << 16) | a;\n }\n\n /**\n * @param {Uint8Array} literals The input data.\n * @returns {Uint8Array} The DEFLATE-compressed data stream in zlib format.\n * This is the required format for compressed streams in the PNG format:\n * http://www.libpng.org/pub/png/spec/1.2/PNG-Compression.html\n */\n function deflateSync(literals) {\n if (!isNodeJS) {\n // zlib is certainly not available outside of Node.js. We can either use\n // the pako library for client-side DEFLATE compression, or use the\n // canvas API of the browser to obtain a more optimal PNG file.\n return deflateSyncUncompressed(literals);\n }\n try {\n // NOTE: This implementation is far from perfect, but already way better\n // than not applying any compression.\n //\n // A better algorithm will try to choose a good predictor/filter and\n // then choose a suitable zlib compression strategy (e.g. 3,Z_RLE).\n //\n // Node v0.11.12 zlib.deflateSync is introduced (and returns a Buffer).\n // Node v3.0.0 Buffer inherits from Uint8Array.\n // Node v8.0.0 zlib.deflateSync accepts Uint8Array as input.\n let input;\n // eslint-disable-next-line no-undef\n if (parseInt(process.versions.node) >= 8) {\n input = literals;\n } else {\n // eslint-disable-next-line no-undef\n input = Buffer.from(literals);\n }\n const output = __non_webpack_require__(\"zlib\").deflateSync(input, {\n level: 9,\n });\n return output instanceof Uint8Array ? output : new Uint8Array(output);\n } catch (e) {\n warn(\n \"Not compressing PNG because zlib.deflateSync is unavailable: \" + e\n );\n }\n\n return deflateSyncUncompressed(literals);\n }\n\n // An implementation of DEFLATE with compression level 0 (Z_NO_COMPRESSION).\n function deflateSyncUncompressed(literals) {\n let len = literals.length;\n const maxBlockLength = 0xffff;\n\n const deflateBlocks = Math.ceil(len / maxBlockLength);\n const idat = new Uint8Array(2 + len + deflateBlocks * 5 + 4);\n let pi = 0;\n idat[pi++] = 0x78; // compression method and flags\n idat[pi++] = 0x9c; // flags\n\n let pos = 0;\n while (len > maxBlockLength) {\n // writing non-final DEFLATE blocks type 0 and length of 65535\n idat[pi++] = 0x00;\n idat[pi++] = 0xff;\n idat[pi++] = 0xff;\n idat[pi++] = 0x00;\n idat[pi++] = 0x00;\n idat.set(literals.subarray(pos, pos + maxBlockLength), pi);\n pi += maxBlockLength;\n pos += maxBlockLength;\n len -= maxBlockLength;\n }\n\n // writing non-final DEFLATE blocks type 0\n idat[pi++] = 0x01;\n idat[pi++] = len & 0xff;\n idat[pi++] = (len >> 8) & 0xff;\n idat[pi++] = ~len & 0xffff & 0xff;\n idat[pi++] = ((~len & 0xffff) >> 8) & 0xff;\n idat.set(literals.subarray(pos), pi);\n pi += literals.length - pos;\n\n const adler = adler32(literals, 0, literals.length); // checksum\n idat[pi++] = (adler >> 24) & 0xff;\n idat[pi++] = (adler >> 16) & 0xff;\n idat[pi++] = (adler >> 8) & 0xff;\n idat[pi++] = adler & 0xff;\n return idat;\n }\n\n function encode(imgData, kind, forceDataSchema, isMask) {\n const width = imgData.width;\n const height = imgData.height;\n let bitDepth, colorType, lineSize;\n const bytes = imgData.data;\n\n switch (kind) {\n case ImageKind.GRAYSCALE_1BPP:\n colorType = 0;\n bitDepth = 1;\n lineSize = (width + 7) >> 3;\n break;\n case ImageKind.RGB_24BPP:\n colorType = 2;\n bitDepth = 8;\n lineSize = width * 3;\n break;\n case ImageKind.RGBA_32BPP:\n colorType = 6;\n bitDepth = 8;\n lineSize = width * 4;\n break;\n default:\n throw new Error(\"invalid format\");\n }\n\n // prefix every row with predictor 0\n const literals = new Uint8Array((1 + lineSize) * height);\n let offsetLiterals = 0,\n offsetBytes = 0;\n for (let y = 0; y < height; ++y) {\n literals[offsetLiterals++] = 0; // no prediction\n literals.set(\n bytes.subarray(offsetBytes, offsetBytes + lineSize),\n offsetLiterals\n );\n offsetBytes += lineSize;\n offsetLiterals += lineSize;\n }\n\n if (kind === ImageKind.GRAYSCALE_1BPP && isMask) {\n // inverting for image masks\n offsetLiterals = 0;\n for (let y = 0; y < height; y++) {\n offsetLiterals++; // skipping predictor\n for (let i = 0; i < lineSize; i++) {\n literals[offsetLiterals++] ^= 0xff;\n }\n }\n }\n\n const ihdr = new Uint8Array([\n (width >> 24) & 0xff,\n (width >> 16) & 0xff,\n (width >> 8) & 0xff,\n width & 0xff,\n (height >> 24) & 0xff,\n (height >> 16) & 0xff,\n (height >> 8) & 0xff,\n height & 0xff,\n bitDepth, // bit depth\n colorType, // color type\n 0x00, // compression method\n 0x00, // filter method\n 0x00, // interlace method\n ]);\n const idat = deflateSync(literals);\n\n // PNG consists of: header, IHDR+data, IDAT+data, and IEND.\n const pngLength =\n PNG_HEADER.length + CHUNK_WRAPPER_SIZE * 3 + ihdr.length + idat.length;\n const data = new Uint8Array(pngLength);\n let offset = 0;\n data.set(PNG_HEADER, offset);\n offset += PNG_HEADER.length;\n writePngChunk(\"IHDR\", ihdr, data, offset);\n offset += CHUNK_WRAPPER_SIZE + ihdr.length;\n writePngChunk(\"IDATA\", idat, data, offset);\n offset += CHUNK_WRAPPER_SIZE + idat.length;\n writePngChunk(\"IEND\", new Uint8Array(0), data, offset);\n\n return createObjectURL(data, \"image/png\", forceDataSchema);\n }\n\n // eslint-disable-next-line no-shadow\n return function convertImgDataToPng(imgData, forceDataSchema, isMask) {\n const kind =\n imgData.kind === undefined ? ImageKind.GRAYSCALE_1BPP : imgData.kind;\n return encode(imgData, kind, forceDataSchema, isMask);\n };\n })();\n\n class SVGExtraState {\n constructor() {\n this.fontSizeScale = 1;\n this.fontWeight = SVG_DEFAULTS.fontWeight;\n this.fontSize = 0;\n\n this.textMatrix = IDENTITY_MATRIX;\n this.fontMatrix = FONT_IDENTITY_MATRIX;\n this.leading = 0;\n this.textRenderingMode = TextRenderingMode.FILL;\n this.textMatrixScale = 1;\n\n // Current point (in user coordinates)\n this.x = 0;\n this.y = 0;\n\n // Start of text line (in text coordinates)\n this.lineX = 0;\n this.lineY = 0;\n\n // Character and word spacing\n this.charSpacing = 0;\n this.wordSpacing = 0;\n this.textHScale = 1;\n this.textRise = 0;\n\n // Default foreground and background colors\n this.fillColor = SVG_DEFAULTS.fillColor;\n this.strokeColor = \"#000000\";\n\n this.fillAlpha = 1;\n this.strokeAlpha = 1;\n this.lineWidth = 1;\n this.lineJoin = \"\";\n this.lineCap = \"\";\n this.miterLimit = 0;\n\n this.dashArray = [];\n this.dashPhase = 0;\n\n this.dependencies = [];\n\n // Clipping\n this.activeClipUrl = null;\n this.clipGroup = null;\n\n this.maskId = \"\";\n }\n\n clone() {\n return Object.create(this);\n }\n\n setCurrentPoint(x, y) {\n this.x = x;\n this.y = y;\n }\n }\n\n // eslint-disable-next-line no-inner-declarations\n function opListToTree(opList) {\n let opTree = [];\n const tmp = [];\n\n for (const opListElement of opList) {\n if (opListElement.fn === \"save\") {\n opTree.push({ fnId: 92, fn: \"group\", items: [] });\n tmp.push(opTree);\n opTree = opTree[opTree.length - 1].items;\n continue;\n }\n\n if (opListElement.fn === \"restore\") {\n opTree = tmp.pop();\n } else {\n opTree.push(opListElement);\n }\n }\n return opTree;\n }\n\n /**\n * Format a float number as a string.\n *\n * @param value {number} - The float number to format.\n * @returns {string}\n */\n // eslint-disable-next-line no-inner-declarations\n function pf(value) {\n if (Number.isInteger(value)) {\n return value.toString();\n }\n const s = value.toFixed(10);\n let i = s.length - 1;\n if (s[i] !== \"0\") {\n return s;\n }\n\n // Remove trailing zeros.\n do {\n i--;\n } while (s[i] === \"0\");\n return s.substring(0, s[i] === \".\" ? i : i + 1);\n }\n\n /**\n * Format a transform matrix as a string. The standard rotation, scale and\n * translation matrices are replaced by their shorter forms, and for\n * identity matrices an empty string is returned to save memory.\n *\n * @param m {Array} - The transform matrix to format.\n * @returns {string}\n */\n // eslint-disable-next-line no-inner-declarations\n function pm(m) {\n if (m[4] === 0 && m[5] === 0) {\n if (m[1] === 0 && m[2] === 0) {\n if (m[0] === 1 && m[3] === 1) {\n return \"\";\n }\n return `scale(${pf(m[0])} ${pf(m[3])})`;\n }\n if (m[0] === m[3] && m[1] === -m[2]) {\n const a = (Math.acos(m[0]) * 180) / Math.PI;\n return `rotate(${pf(a)})`;\n }\n } else {\n if (m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1) {\n return `translate(${pf(m[4])} ${pf(m[5])})`;\n }\n }\n return (\n `matrix(${pf(m[0])} ${pf(m[1])} ${pf(m[2])} ${pf(m[3])} ${pf(m[4])} ` +\n `${pf(m[5])})`\n );\n }\n\n // The counts below are relevant for all pages, so they have to be global\n // instead of being members of `SVGGraphics` (which is recreated for\n // each page).\n let clipCount = 0;\n let maskCount = 0;\n let shadingCount = 0;\n\n // eslint-disable-next-line no-shadow\n SVGGraphics = class SVGGraphics {\n constructor(commonObjs, objs, forceDataSchema = false) {\n this.svgFactory = new DOMSVGFactory();\n\n this.current = new SVGExtraState();\n this.transformMatrix = IDENTITY_MATRIX; // Graphics state matrix\n this.transformStack = [];\n this.extraStack = [];\n this.commonObjs = commonObjs;\n this.objs = objs;\n this.pendingClip = null;\n this.pendingEOFill = false;\n\n this.embedFonts = false;\n this.embeddedFonts = Object.create(null);\n this.cssStyle = null;\n this.forceDataSchema = !!forceDataSchema;\n\n // In `src/shared/util.js` the operator names are mapped to IDs.\n // The list below represents the reverse of that, i.e., it maps IDs\n // to operator names.\n this._operatorIdMapping = [];\n for (const op in OPS) {\n this._operatorIdMapping[OPS[op]] = op;\n }\n }\n\n save() {\n this.transformStack.push(this.transformMatrix);\n const old = this.current;\n this.extraStack.push(old);\n this.current = old.clone();\n }\n\n restore() {\n this.transformMatrix = this.transformStack.pop();\n this.current = this.extraStack.pop();\n this.pendingClip = null;\n this.tgrp = null;\n }\n\n group(items) {\n this.save();\n this.executeOpTree(items);\n this.restore();\n }\n\n loadDependencies(operatorList) {\n const fnArray = operatorList.fnArray;\n const argsArray = operatorList.argsArray;\n\n for (let i = 0, ii = fnArray.length; i < ii; i++) {\n if (fnArray[i] !== OPS.dependency) {\n continue;\n }\n\n for (const obj of argsArray[i]) {\n const objsPool = obj.startsWith(\"g_\") ? this.commonObjs : this.objs;\n const promise = new Promise(resolve => {\n objsPool.get(obj, resolve);\n });\n this.current.dependencies.push(promise);\n }\n }\n return Promise.all(this.current.dependencies);\n }\n\n transform(a, b, c, d, e, f) {\n const transformMatrix = [a, b, c, d, e, f];\n this.transformMatrix = Util.transform(\n this.transformMatrix,\n transformMatrix\n );\n this.tgrp = null;\n }\n\n getSVG(operatorList, viewport) {\n this.viewport = viewport;\n\n const svgElement = this._initialize(viewport);\n return this.loadDependencies(operatorList).then(() => {\n this.transformMatrix = IDENTITY_MATRIX;\n this.executeOpTree(this.convertOpList(operatorList));\n return svgElement;\n });\n }\n\n convertOpList(operatorList) {\n const operatorIdMapping = this._operatorIdMapping;\n const argsArray = operatorList.argsArray;\n const fnArray = operatorList.fnArray;\n const opList = [];\n for (let i = 0, ii = fnArray.length; i < ii; i++) {\n const fnId = fnArray[i];\n opList.push({\n fnId,\n fn: operatorIdMapping[fnId],\n args: argsArray[i],\n });\n }\n return opListToTree(opList);\n }\n\n executeOpTree(opTree) {\n for (const opTreeElement of opTree) {\n const fn = opTreeElement.fn;\n const fnId = opTreeElement.fnId;\n const args = opTreeElement.args;\n\n switch (fnId | 0) {\n case OPS.beginText:\n this.beginText();\n break;\n case OPS.dependency:\n // Handled in `loadDependencies`, so no warning should be shown.\n break;\n case OPS.setLeading:\n this.setLeading(args);\n break;\n case OPS.setLeadingMoveText:\n this.setLeadingMoveText(args[0], args[1]);\n break;\n case OPS.setFont:\n this.setFont(args);\n break;\n case OPS.showText:\n this.showText(args[0]);\n break;\n case OPS.showSpacedText:\n this.showText(args[0]);\n break;\n case OPS.endText:\n this.endText();\n break;\n case OPS.moveText:\n this.moveText(args[0], args[1]);\n break;\n case OPS.setCharSpacing:\n this.setCharSpacing(args[0]);\n break;\n case OPS.setWordSpacing:\n this.setWordSpacing(args[0]);\n break;\n case OPS.setHScale:\n this.setHScale(args[0]);\n break;\n case OPS.setTextMatrix:\n this.setTextMatrix(\n args[0],\n args[1],\n args[2],\n args[3],\n args[4],\n args[5]\n );\n break;\n case OPS.setTextRise:\n this.setTextRise(args[0]);\n break;\n case OPS.setTextRenderingMode:\n this.setTextRenderingMode(args[0]);\n break;\n case OPS.setLineWidth:\n this.setLineWidth(args[0]);\n break;\n case OPS.setLineJoin:\n this.setLineJoin(args[0]);\n break;\n case OPS.setLineCap:\n this.setLineCap(args[0]);\n break;\n case OPS.setMiterLimit:\n this.setMiterLimit(args[0]);\n break;\n case OPS.setFillRGBColor:\n this.setFillRGBColor(args[0], args[1], args[2]);\n break;\n case OPS.setStrokeRGBColor:\n this.setStrokeRGBColor(args[0], args[1], args[2]);\n break;\n case OPS.setStrokeColorN:\n this.setStrokeColorN(args);\n break;\n case OPS.setFillColorN:\n this.setFillColorN(args);\n break;\n case OPS.shadingFill:\n this.shadingFill(args[0]);\n break;\n case OPS.setDash:\n this.setDash(args[0], args[1]);\n break;\n case OPS.setRenderingIntent:\n this.setRenderingIntent(args[0]);\n break;\n case OPS.setFlatness:\n this.setFlatness(args[0]);\n break;\n case OPS.setGState:\n this.setGState(args[0]);\n break;\n case OPS.fill:\n this.fill();\n break;\n case OPS.eoFill:\n this.eoFill();\n break;\n case OPS.stroke:\n this.stroke();\n break;\n case OPS.fillStroke:\n this.fillStroke();\n break;\n case OPS.eoFillStroke:\n this.eoFillStroke();\n break;\n case OPS.clip:\n this.clip(\"nonzero\");\n break;\n case OPS.eoClip:\n this.clip(\"evenodd\");\n break;\n case OPS.paintSolidColorImageMask:\n this.paintSolidColorImageMask();\n break;\n case OPS.paintImageXObject:\n this.paintImageXObject(args[0]);\n break;\n case OPS.paintInlineImageXObject:\n this.paintInlineImageXObject(args[0]);\n break;\n case OPS.paintImageMaskXObject:\n this.paintImageMaskXObject(args[0]);\n break;\n case OPS.paintFormXObjectBegin:\n this.paintFormXObjectBegin(args[0], args[1]);\n break;\n case OPS.paintFormXObjectEnd:\n this.paintFormXObjectEnd();\n break;\n case OPS.closePath:\n this.closePath();\n break;\n case OPS.closeStroke:\n this.closeStroke();\n break;\n case OPS.closeFillStroke:\n this.closeFillStroke();\n break;\n case OPS.closeEOFillStroke:\n this.closeEOFillStroke();\n break;\n case OPS.nextLine:\n this.nextLine();\n break;\n case OPS.transform:\n this.transform(\n args[0],\n args[1],\n args[2],\n args[3],\n args[4],\n args[5]\n );\n break;\n case OPS.constructPath:\n this.constructPath(args[0], args[1]);\n break;\n case OPS.endPath:\n this.endPath();\n break;\n case 92:\n this.group(opTreeElement.items);\n break;\n default:\n warn(`Unimplemented operator ${fn}`);\n break;\n }\n }\n }\n\n setWordSpacing(wordSpacing) {\n this.current.wordSpacing = wordSpacing;\n }\n\n setCharSpacing(charSpacing) {\n this.current.charSpacing = charSpacing;\n }\n\n nextLine() {\n this.moveText(0, this.current.leading);\n }\n\n setTextMatrix(a, b, c, d, e, f) {\n const current = this.current;\n current.textMatrix = current.lineMatrix = [a, b, c, d, e, f];\n current.textMatrixScale = Math.sqrt(a * a + b * b);\n\n current.x = current.lineX = 0;\n current.y = current.lineY = 0;\n\n current.xcoords = [];\n current.ycoords = [];\n current.tspan = this.svgFactory.createElement(\"svg:tspan\");\n current.tspan.setAttributeNS(null, \"font-family\", current.fontFamily);\n current.tspan.setAttributeNS(\n null,\n \"font-size\",\n `${pf(current.fontSize)}px`\n );\n current.tspan.setAttributeNS(null, \"y\", pf(-current.y));\n\n current.txtElement = this.svgFactory.createElement(\"svg:text\");\n current.txtElement.appendChild(current.tspan);\n }\n\n beginText() {\n const current = this.current;\n current.x = current.lineX = 0;\n current.y = current.lineY = 0;\n current.textMatrix = IDENTITY_MATRIX;\n current.lineMatrix = IDENTITY_MATRIX;\n current.textMatrixScale = 1;\n current.tspan = this.svgFactory.createElement(\"svg:tspan\");\n current.txtElement = this.svgFactory.createElement(\"svg:text\");\n current.txtgrp = this.svgFactory.createElement(\"svg:g\");\n current.xcoords = [];\n current.ycoords = [];\n }\n\n moveText(x, y) {\n const current = this.current;\n current.x = current.lineX += x;\n current.y = current.lineY += y;\n\n current.xcoords = [];\n current.ycoords = [];\n current.tspan = this.svgFactory.createElement(\"svg:tspan\");\n current.tspan.setAttributeNS(null, \"font-family\", current.fontFamily);\n current.tspan.setAttributeNS(\n null,\n \"font-size\",\n `${pf(current.fontSize)}px`\n );\n current.tspan.setAttributeNS(null, \"y\", pf(-current.y));\n }\n\n showText(glyphs) {\n const current = this.current;\n const font = current.font;\n const fontSize = current.fontSize;\n if (fontSize === 0) {\n return;\n }\n\n const fontSizeScale = current.fontSizeScale;\n const charSpacing = current.charSpacing;\n const wordSpacing = current.wordSpacing;\n const fontDirection = current.fontDirection;\n const textHScale = current.textHScale * fontDirection;\n const vertical = font.vertical;\n const spacingDir = vertical ? 1 : -1;\n const defaultVMetrics = font.defaultVMetrics;\n const widthAdvanceScale = fontSize * current.fontMatrix[0];\n\n let x = 0;\n for (const glyph of glyphs) {\n if (glyph === null) {\n // Word break\n x += fontDirection * wordSpacing;\n continue;\n } else if (isNum(glyph)) {\n x += (spacingDir * glyph * fontSize) / 1000;\n continue;\n }\n\n const spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;\n const character = glyph.fontChar;\n let scaledX, scaledY;\n let width = glyph.width;\n if (vertical) {\n let vx;\n const vmetric = glyph.vmetric || defaultVMetrics;\n vx = glyph.vmetric ? vmetric[1] : width * 0.5;\n vx = -vx * widthAdvanceScale;\n const vy = vmetric[2] * widthAdvanceScale;\n\n width = vmetric ? -vmetric[0] : width;\n scaledX = vx / fontSizeScale;\n scaledY = (x + vy) / fontSizeScale;\n } else {\n scaledX = x / fontSizeScale;\n scaledY = 0;\n }\n\n if (glyph.isInFont || font.missingFile) {\n current.xcoords.push(current.x + scaledX);\n if (vertical) {\n current.ycoords.push(-current.y + scaledY);\n }\n current.tspan.textContent += character;\n } else {\n // TODO: To assist with text selection, we should replace the missing\n // character with a space character if charWidth is not zero.\n // But we cannot just do \"character = ' '\", because the ' ' character\n // might actually map to a different glyph.\n }\n\n let charWidth;\n if (vertical) {\n charWidth = width * widthAdvanceScale - spacing * fontDirection;\n } else {\n charWidth = width * widthAdvanceScale + spacing * fontDirection;\n }\n\n x += charWidth;\n }\n current.tspan.setAttributeNS(\n null,\n \"x\",\n current.xcoords.map(pf).join(\" \")\n );\n if (vertical) {\n current.tspan.setAttributeNS(\n null,\n \"y\",\n current.ycoords.map(pf).join(\" \")\n );\n } else {\n current.tspan.setAttributeNS(null, \"y\", pf(-current.y));\n }\n\n if (vertical) {\n current.y -= x;\n } else {\n current.x += x * textHScale;\n }\n\n current.tspan.setAttributeNS(null, \"font-family\", current.fontFamily);\n current.tspan.setAttributeNS(\n null,\n \"font-size\",\n `${pf(current.fontSize)}px`\n );\n if (current.fontStyle !== SVG_DEFAULTS.fontStyle) {\n current.tspan.setAttributeNS(null, \"font-style\", current.fontStyle);\n }\n if (current.fontWeight !== SVG_DEFAULTS.fontWeight) {\n current.tspan.setAttributeNS(null, \"font-weight\", current.fontWeight);\n }\n\n const fillStrokeMode =\n current.textRenderingMode & TextRenderingMode.FILL_STROKE_MASK;\n if (\n fillStrokeMode === TextRenderingMode.FILL ||\n fillStrokeMode === TextRenderingMode.FILL_STROKE\n ) {\n if (current.fillColor !== SVG_DEFAULTS.fillColor) {\n current.tspan.setAttributeNS(null, \"fill\", current.fillColor);\n }\n if (current.fillAlpha < 1) {\n current.tspan.setAttributeNS(null, \"fill-opacity\", current.fillAlpha);\n }\n } else if (current.textRenderingMode === TextRenderingMode.ADD_TO_PATH) {\n // Workaround for Firefox: We must set fill=\"transparent\" because\n // fill=\"none\" would generate an empty clipping path.\n current.tspan.setAttributeNS(null, \"fill\", \"transparent\");\n } else {\n current.tspan.setAttributeNS(null, \"fill\", \"none\");\n }\n\n if (\n fillStrokeMode === TextRenderingMode.STROKE ||\n fillStrokeMode === TextRenderingMode.FILL_STROKE\n ) {\n const lineWidthScale = 1 / (current.textMatrixScale || 1);\n this._setStrokeAttributes(current.tspan, lineWidthScale);\n }\n\n // Include the text rise in the text matrix since the `pm` function\n // creates the SVG element's `translate` entry (work on a copy to avoid\n // altering the original text matrix).\n let textMatrix = current.textMatrix;\n if (current.textRise !== 0) {\n textMatrix = textMatrix.slice();\n textMatrix[5] += current.textRise;\n }\n\n current.txtElement.setAttributeNS(\n null,\n \"transform\",\n `${pm(textMatrix)} scale(${pf(textHScale)}, -1)`\n );\n current.txtElement.setAttributeNS(XML_NS, \"xml:space\", \"preserve\");\n current.txtElement.appendChild(current.tspan);\n current.txtgrp.appendChild(current.txtElement);\n\n this._ensureTransformGroup().appendChild(current.txtElement);\n }\n\n setLeadingMoveText(x, y) {\n this.setLeading(-y);\n this.moveText(x, y);\n }\n\n addFontStyle(fontObj) {\n if (!fontObj.data) {\n throw new Error(\n \"addFontStyle: No font data available, \" +\n 'ensure that the \"fontExtraProperties\" API parameter is set.'\n );\n }\n if (!this.cssStyle) {\n this.cssStyle = this.svgFactory.createElement(\"svg:style\");\n this.cssStyle.setAttributeNS(null, \"type\", \"text/css\");\n this.defs.appendChild(this.cssStyle);\n }\n\n const url = createObjectURL(\n fontObj.data,\n fontObj.mimetype,\n this.forceDataSchema\n );\n this.cssStyle.textContent +=\n `@font-face { font-family: \"${fontObj.loadedName}\";` +\n ` src: url(${url}); }\\n`;\n }\n\n setFont(details) {\n const current = this.current;\n const fontObj = this.commonObjs.get(details[0]);\n let size = details[1];\n current.font = fontObj;\n\n if (\n this.embedFonts &&\n !fontObj.missingFile &&\n !this.embeddedFonts[fontObj.loadedName]\n ) {\n this.addFontStyle(fontObj);\n this.embeddedFonts[fontObj.loadedName] = fontObj;\n }\n\n current.fontMatrix = fontObj.fontMatrix\n ? fontObj.fontMatrix\n : FONT_IDENTITY_MATRIX;\n\n let bold = \"normal\";\n if (fontObj.black) {\n bold = \"900\";\n } else if (fontObj.bold) {\n bold = \"bold\";\n }\n const italic = fontObj.italic ? \"italic\" : \"normal\";\n\n if (size < 0) {\n size = -size;\n current.fontDirection = -1;\n } else {\n current.fontDirection = 1;\n }\n current.fontSize = size;\n current.fontFamily = fontObj.loadedName;\n current.fontWeight = bold;\n current.fontStyle = italic;\n\n current.tspan = this.svgFactory.createElement(\"svg:tspan\");\n current.tspan.setAttributeNS(null, \"y\", pf(-current.y));\n current.xcoords = [];\n current.ycoords = [];\n }\n\n endText() {\n const current = this.current;\n if (\n current.textRenderingMode & TextRenderingMode.ADD_TO_PATH_FLAG &&\n current.txtElement &&\n current.txtElement.hasChildNodes()\n ) {\n // If no glyphs are shown (i.e. no child nodes), no clipping occurs.\n current.element = current.txtElement;\n this.clip(\"nonzero\");\n this.endPath();\n }\n }\n\n // Path properties\n setLineWidth(width) {\n if (width > 0) {\n this.current.lineWidth = width;\n }\n }\n\n setLineCap(style) {\n this.current.lineCap = LINE_CAP_STYLES[style];\n }\n\n setLineJoin(style) {\n this.current.lineJoin = LINE_JOIN_STYLES[style];\n }\n\n setMiterLimit(limit) {\n this.current.miterLimit = limit;\n }\n\n setStrokeAlpha(strokeAlpha) {\n this.current.strokeAlpha = strokeAlpha;\n }\n\n setStrokeRGBColor(r, g, b) {\n this.current.strokeColor = Util.makeCssRgb(r, g, b);\n }\n\n setFillAlpha(fillAlpha) {\n this.current.fillAlpha = fillAlpha;\n }\n\n setFillRGBColor(r, g, b) {\n this.current.fillColor = Util.makeCssRgb(r, g, b);\n this.current.tspan = this.svgFactory.createElement(\"svg:tspan\");\n this.current.xcoords = [];\n this.current.ycoords = [];\n }\n\n setStrokeColorN(args) {\n this.current.strokeColor = this._makeColorN_Pattern(args);\n }\n\n setFillColorN(args) {\n this.current.fillColor = this._makeColorN_Pattern(args);\n }\n\n shadingFill(args) {\n const width = this.viewport.width;\n const height = this.viewport.height;\n const inv = Util.inverseTransform(this.transformMatrix);\n const bl = Util.applyTransform([0, 0], inv);\n const br = Util.applyTransform([0, height], inv);\n const ul = Util.applyTransform([width, 0], inv);\n const ur = Util.applyTransform([width, height], inv);\n const x0 = Math.min(bl[0], br[0], ul[0], ur[0]);\n const y0 = Math.min(bl[1], br[1], ul[1], ur[1]);\n const x1 = Math.max(bl[0], br[0], ul[0], ur[0]);\n const y1 = Math.max(bl[1], br[1], ul[1], ur[1]);\n\n const rect = this.svgFactory.createElement(\"svg:rect\");\n rect.setAttributeNS(null, \"x\", x0);\n rect.setAttributeNS(null, \"y\", y0);\n rect.setAttributeNS(null, \"width\", x1 - x0);\n rect.setAttributeNS(null, \"height\", y1 - y0);\n rect.setAttributeNS(null, \"fill\", this._makeShadingPattern(args));\n if (this.current.fillAlpha < 1) {\n rect.setAttributeNS(null, \"fill-opacity\", this.current.fillAlpha);\n }\n this._ensureTransformGroup().appendChild(rect);\n }\n\n /**\n * @private\n */\n _makeColorN_Pattern(args) {\n if (args[0] === \"TilingPattern\") {\n return this._makeTilingPattern(args);\n }\n return this._makeShadingPattern(args);\n }\n\n /**\n * @private\n */\n _makeTilingPattern(args) {\n const color = args[1];\n const operatorList = args[2];\n const matrix = args[3] || IDENTITY_MATRIX;\n const [x0, y0, x1, y1] = args[4];\n const xstep = args[5];\n const ystep = args[6];\n const paintType = args[7];\n\n const tilingId = `shading${shadingCount++}`;\n const [tx0, ty0] = Util.applyTransform([x0, y0], matrix);\n const [tx1, ty1] = Util.applyTransform([x1, y1], matrix);\n const [xscale, yscale] = Util.singularValueDecompose2dScale(matrix);\n const txstep = xstep * xscale;\n const tystep = ystep * yscale;\n\n const tiling = this.svgFactory.createElement(\"svg:pattern\");\n tiling.setAttributeNS(null, \"id\", tilingId);\n tiling.setAttributeNS(null, \"patternUnits\", \"userSpaceOnUse\");\n tiling.setAttributeNS(null, \"width\", txstep);\n tiling.setAttributeNS(null, \"height\", tystep);\n tiling.setAttributeNS(null, \"x\", `${tx0}`);\n tiling.setAttributeNS(null, \"y\", `${ty0}`);\n\n // Save current state.\n const svg = this.svg;\n const transformMatrix = this.transformMatrix;\n const fillColor = this.current.fillColor;\n const strokeColor = this.current.strokeColor;\n\n const bbox = this.svgFactory.create(tx1 - tx0, ty1 - ty0);\n this.svg = bbox;\n this.transformMatrix = matrix;\n if (paintType === 2) {\n const cssColor = Util.makeCssRgb(...color);\n this.current.fillColor = cssColor;\n this.current.strokeColor = cssColor;\n }\n this.executeOpTree(this.convertOpList(operatorList));\n\n // Restore saved state.\n this.svg = svg;\n this.transformMatrix = transformMatrix;\n this.current.fillColor = fillColor;\n this.current.strokeColor = strokeColor;\n\n tiling.appendChild(bbox.childNodes[0]);\n this.defs.appendChild(tiling);\n return `url(#${tilingId})`;\n }\n\n /**\n * @private\n */\n _makeShadingPattern(args) {\n switch (args[0]) {\n case \"RadialAxial\":\n const shadingId = `shading${shadingCount++}`;\n const colorStops = args[3];\n let gradient;\n\n switch (args[1]) {\n case \"axial\":\n const point0 = args[4];\n const point1 = args[5];\n gradient = this.svgFactory.createElement(\"svg:linearGradient\");\n gradient.setAttributeNS(null, \"id\", shadingId);\n gradient.setAttributeNS(null, \"gradientUnits\", \"userSpaceOnUse\");\n gradient.setAttributeNS(null, \"x1\", point0[0]);\n gradient.setAttributeNS(null, \"y1\", point0[1]);\n gradient.setAttributeNS(null, \"x2\", point1[0]);\n gradient.setAttributeNS(null, \"y2\", point1[1]);\n break;\n case \"radial\":\n const focalPoint = args[4];\n const circlePoint = args[5];\n const focalRadius = args[6];\n const circleRadius = args[7];\n gradient = this.svgFactory.createElement(\"svg:radialGradient\");\n gradient.setAttributeNS(null, \"id\", shadingId);\n gradient.setAttributeNS(null, \"gradientUnits\", \"userSpaceOnUse\");\n gradient.setAttributeNS(null, \"cx\", circlePoint[0]);\n gradient.setAttributeNS(null, \"cy\", circlePoint[1]);\n gradient.setAttributeNS(null, \"r\", circleRadius);\n gradient.setAttributeNS(null, \"fx\", focalPoint[0]);\n gradient.setAttributeNS(null, \"fy\", focalPoint[1]);\n gradient.setAttributeNS(null, \"fr\", focalRadius);\n break;\n default:\n throw new Error(`Unknown RadialAxial type: ${args[1]}`);\n }\n for (const colorStop of colorStops) {\n const stop = this.svgFactory.createElement(\"svg:stop\");\n stop.setAttributeNS(null, \"offset\", colorStop[0]);\n stop.setAttributeNS(null, \"stop-color\", colorStop[1]);\n gradient.appendChild(stop);\n }\n this.defs.appendChild(gradient);\n return `url(#${shadingId})`;\n case \"Mesh\":\n warn(\"Unimplemented pattern Mesh\");\n return null;\n case \"Dummy\":\n return \"hotpink\";\n default:\n throw new Error(`Unknown IR type: ${args[0]}`);\n }\n }\n\n setDash(dashArray, dashPhase) {\n this.current.dashArray = dashArray;\n this.current.dashPhase = dashPhase;\n }\n\n constructPath(ops, args) {\n const current = this.current;\n let x = current.x,\n y = current.y;\n let d = [];\n let j = 0;\n\n for (const op of ops) {\n switch (op | 0) {\n case OPS.rectangle:\n x = args[j++];\n y = args[j++];\n const width = args[j++];\n const height = args[j++];\n const xw = x + width;\n const yh = y + height;\n d.push(\n \"M\",\n pf(x),\n pf(y),\n \"L\",\n pf(xw),\n pf(y),\n \"L\",\n pf(xw),\n pf(yh),\n \"L\",\n pf(x),\n pf(yh),\n \"Z\"\n );\n break;\n case OPS.moveTo:\n x = args[j++];\n y = args[j++];\n d.push(\"M\", pf(x), pf(y));\n break;\n case OPS.lineTo:\n x = args[j++];\n y = args[j++];\n d.push(\"L\", pf(x), pf(y));\n break;\n case OPS.curveTo:\n x = args[j + 4];\n y = args[j + 5];\n d.push(\n \"C\",\n pf(args[j]),\n pf(args[j + 1]),\n pf(args[j + 2]),\n pf(args[j + 3]),\n pf(x),\n pf(y)\n );\n j += 6;\n break;\n case OPS.curveTo2:\n d.push(\n \"C\",\n pf(x),\n pf(y),\n pf(args[j]),\n pf(args[j + 1]),\n pf(args[j + 2]),\n pf(args[j + 3])\n );\n x = args[j + 2];\n y = args[j + 3];\n j += 4;\n break;\n case OPS.curveTo3:\n x = args[j + 2];\n y = args[j + 3];\n d.push(\n \"C\",\n pf(args[j]),\n pf(args[j + 1]),\n pf(x),\n pf(y),\n pf(x),\n pf(y)\n );\n j += 4;\n break;\n case OPS.closePath:\n d.push(\"Z\");\n break;\n }\n }\n\n d = d.join(\" \");\n\n if (\n current.path &&\n ops.length > 0 &&\n ops[0] !== OPS.rectangle &&\n ops[0] !== OPS.moveTo\n ) {\n // If a path does not start with an OPS.rectangle or OPS.moveTo, it has\n // probably been divided into two OPS.constructPath operators by\n // OperatorList. Append the commands to the previous path element.\n d = current.path.getAttributeNS(null, \"d\") + d;\n } else {\n current.path = this.svgFactory.createElement(\"svg:path\");\n this._ensureTransformGroup().appendChild(current.path);\n }\n\n current.path.setAttributeNS(null, \"d\", d);\n current.path.setAttributeNS(null, \"fill\", \"none\");\n\n // Saving a reference in current.element so that it can be addressed\n // in 'fill' and 'stroke'\n current.element = current.path;\n current.setCurrentPoint(x, y);\n }\n\n endPath() {\n const current = this.current;\n\n // Painting operators end a path.\n current.path = null;\n\n if (!this.pendingClip) {\n return;\n }\n if (!current.element) {\n this.pendingClip = null;\n return;\n }\n\n // Add the current path to a clipping path.\n const clipId = `clippath${clipCount++}`;\n const clipPath = this.svgFactory.createElement(\"svg:clipPath\");\n clipPath.setAttributeNS(null, \"id\", clipId);\n clipPath.setAttributeNS(null, \"transform\", pm(this.transformMatrix));\n\n // A deep clone is needed when text is used as a clipping path.\n const clipElement = current.element.cloneNode(true);\n if (this.pendingClip === \"evenodd\") {\n clipElement.setAttributeNS(null, \"clip-rule\", \"evenodd\");\n } else {\n clipElement.setAttributeNS(null, \"clip-rule\", \"nonzero\");\n }\n this.pendingClip = null;\n clipPath.appendChild(clipElement);\n this.defs.appendChild(clipPath);\n\n if (current.activeClipUrl) {\n // The previous clipping group content can go out of order -- resetting\n // cached clipGroups.\n current.clipGroup = null;\n this.extraStack.forEach(function (prev) {\n prev.clipGroup = null;\n });\n // Intersect with the previous clipping path.\n clipPath.setAttributeNS(null, \"clip-path\", current.activeClipUrl);\n }\n current.activeClipUrl = `url(#${clipId})`;\n\n this.tgrp = null;\n }\n\n clip(type) {\n this.pendingClip = type;\n }\n\n closePath() {\n const current = this.current;\n if (current.path) {\n const d = `${current.path.getAttributeNS(null, \"d\")}Z`;\n current.path.setAttributeNS(null, \"d\", d);\n }\n }\n\n setLeading(leading) {\n this.current.leading = -leading;\n }\n\n setTextRise(textRise) {\n this.current.textRise = textRise;\n }\n\n setTextRenderingMode(textRenderingMode) {\n this.current.textRenderingMode = textRenderingMode;\n }\n\n setHScale(scale) {\n this.current.textHScale = scale / 100;\n }\n\n setRenderingIntent(intent) {\n // This operation is ignored since we haven't found a use case for it yet.\n }\n\n setFlatness(flatness) {\n // This operation is ignored since we haven't found a use case for it yet.\n }\n\n setGState(states) {\n for (const [key, value] of states) {\n switch (key) {\n case \"LW\":\n this.setLineWidth(value);\n break;\n case \"LC\":\n this.setLineCap(value);\n break;\n case \"LJ\":\n this.setLineJoin(value);\n break;\n case \"ML\":\n this.setMiterLimit(value);\n break;\n case \"D\":\n this.setDash(value[0], value[1]);\n break;\n case \"RI\":\n this.setRenderingIntent(value);\n break;\n case \"FL\":\n this.setFlatness(value);\n break;\n case \"Font\":\n this.setFont(value);\n break;\n case \"CA\":\n this.setStrokeAlpha(value);\n break;\n case \"ca\":\n this.setFillAlpha(value);\n break;\n default:\n warn(`Unimplemented graphic state operator ${key}`);\n break;\n }\n }\n }\n\n fill() {\n const current = this.current;\n if (current.element) {\n current.element.setAttributeNS(null, \"fill\", current.fillColor);\n current.element.setAttributeNS(null, \"fill-opacity\", current.fillAlpha);\n this.endPath();\n }\n }\n\n stroke() {\n const current = this.current;\n if (current.element) {\n this._setStrokeAttributes(current.element);\n current.element.setAttributeNS(null, \"fill\", \"none\");\n this.endPath();\n }\n }\n\n /**\n * @private\n */\n _setStrokeAttributes(element, lineWidthScale = 1) {\n const current = this.current;\n let dashArray = current.dashArray;\n if (lineWidthScale !== 1 && dashArray.length > 0) {\n dashArray = dashArray.map(function (value) {\n return lineWidthScale * value;\n });\n }\n element.setAttributeNS(null, \"stroke\", current.strokeColor);\n element.setAttributeNS(null, \"stroke-opacity\", current.strokeAlpha);\n element.setAttributeNS(null, \"stroke-miterlimit\", pf(current.miterLimit));\n element.setAttributeNS(null, \"stroke-linecap\", current.lineCap);\n element.setAttributeNS(null, \"stroke-linejoin\", current.lineJoin);\n element.setAttributeNS(\n null,\n \"stroke-width\",\n pf(lineWidthScale * current.lineWidth) + \"px\"\n );\n element.setAttributeNS(\n null,\n \"stroke-dasharray\",\n dashArray.map(pf).join(\" \")\n );\n element.setAttributeNS(\n null,\n \"stroke-dashoffset\",\n pf(lineWidthScale * current.dashPhase) + \"px\"\n );\n }\n\n eoFill() {\n if (this.current.element) {\n this.current.element.setAttributeNS(null, \"fill-rule\", \"evenodd\");\n }\n this.fill();\n }\n\n fillStroke() {\n // Order is important since stroke wants fill to be none.\n // First stroke, then if fill needed, it will be overwritten.\n this.stroke();\n this.fill();\n }\n\n eoFillStroke() {\n if (this.current.element) {\n this.current.element.setAttributeNS(null, \"fill-rule\", \"evenodd\");\n }\n this.fillStroke();\n }\n\n closeStroke() {\n this.closePath();\n this.stroke();\n }\n\n closeFillStroke() {\n this.closePath();\n this.fillStroke();\n }\n\n closeEOFillStroke() {\n this.closePath();\n this.eoFillStroke();\n }\n\n paintSolidColorImageMask() {\n const rect = this.svgFactory.createElement(\"svg:rect\");\n rect.setAttributeNS(null, \"x\", \"0\");\n rect.setAttributeNS(null, \"y\", \"0\");\n rect.setAttributeNS(null, \"width\", \"1px\");\n rect.setAttributeNS(null, \"height\", \"1px\");\n rect.setAttributeNS(null, \"fill\", this.current.fillColor);\n\n this._ensureTransformGroup().appendChild(rect);\n }\n\n paintImageXObject(objId) {\n const imgData = this.objs.get(objId);\n if (!imgData) {\n warn(`Dependent image with object ID ${objId} is not ready yet`);\n return;\n }\n this.paintInlineImageXObject(imgData);\n }\n\n paintInlineImageXObject(imgData, mask) {\n const width = imgData.width;\n const height = imgData.height;\n\n const imgSrc = convertImgDataToPng(imgData, this.forceDataSchema, !!mask);\n const cliprect = this.svgFactory.createElement(\"svg:rect\");\n cliprect.setAttributeNS(null, \"x\", \"0\");\n cliprect.setAttributeNS(null, \"y\", \"0\");\n cliprect.setAttributeNS(null, \"width\", pf(width));\n cliprect.setAttributeNS(null, \"height\", pf(height));\n this.current.element = cliprect;\n this.clip(\"nonzero\");\n\n const imgEl = this.svgFactory.createElement(\"svg:image\");\n imgEl.setAttributeNS(XLINK_NS, \"xlink:href\", imgSrc);\n imgEl.setAttributeNS(null, \"x\", \"0\");\n imgEl.setAttributeNS(null, \"y\", pf(-height));\n imgEl.setAttributeNS(null, \"width\", pf(width) + \"px\");\n imgEl.setAttributeNS(null, \"height\", pf(height) + \"px\");\n imgEl.setAttributeNS(\n null,\n \"transform\",\n `scale(${pf(1 / width)} ${pf(-1 / height)})`\n );\n if (mask) {\n mask.appendChild(imgEl);\n } else {\n this._ensureTransformGroup().appendChild(imgEl);\n }\n }\n\n paintImageMaskXObject(imgData) {\n const current = this.current;\n const width = imgData.width;\n const height = imgData.height;\n const fillColor = current.fillColor;\n\n current.maskId = `mask${maskCount++}`;\n const mask = this.svgFactory.createElement(\"svg:mask\");\n mask.setAttributeNS(null, \"id\", current.maskId);\n\n const rect = this.svgFactory.createElement(\"svg:rect\");\n rect.setAttributeNS(null, \"x\", \"0\");\n rect.setAttributeNS(null, \"y\", \"0\");\n rect.setAttributeNS(null, \"width\", pf(width));\n rect.setAttributeNS(null, \"height\", pf(height));\n rect.setAttributeNS(null, \"fill\", fillColor);\n rect.setAttributeNS(null, \"mask\", `url(#${current.maskId})`);\n\n this.defs.appendChild(mask);\n this._ensureTransformGroup().appendChild(rect);\n\n this.paintInlineImageXObject(imgData, mask);\n }\n\n paintFormXObjectBegin(matrix, bbox) {\n if (Array.isArray(matrix) && matrix.length === 6) {\n this.transform(\n matrix[0],\n matrix[1],\n matrix[2],\n matrix[3],\n matrix[4],\n matrix[5]\n );\n }\n\n if (bbox) {\n const width = bbox[2] - bbox[0];\n const height = bbox[3] - bbox[1];\n\n const cliprect = this.svgFactory.createElement(\"svg:rect\");\n cliprect.setAttributeNS(null, \"x\", bbox[0]);\n cliprect.setAttributeNS(null, \"y\", bbox[1]);\n cliprect.setAttributeNS(null, \"width\", pf(width));\n cliprect.setAttributeNS(null, \"height\", pf(height));\n this.current.element = cliprect;\n this.clip(\"nonzero\");\n this.endPath();\n }\n }\n\n paintFormXObjectEnd() {}\n\n /**\n * @private\n */\n _initialize(viewport) {\n const svg = this.svgFactory.create(viewport.width, viewport.height);\n\n // Create the definitions element.\n const definitions = this.svgFactory.createElement(\"svg:defs\");\n svg.appendChild(definitions);\n this.defs = definitions;\n\n // Create the root group element, which acts a container for all other\n // groups and applies the viewport transform.\n const rootGroup = this.svgFactory.createElement(\"svg:g\");\n rootGroup.setAttributeNS(null, \"transform\", pm(viewport.transform));\n svg.appendChild(rootGroup);\n\n // For the construction of the SVG image we are only interested in the\n // root group, so we expose it as the entry point of the SVG image for\n // the other code in this class.\n this.svg = rootGroup;\n\n return svg;\n }\n\n /**\n * @private\n */\n _ensureClipGroup() {\n if (!this.current.clipGroup) {\n const clipGroup = this.svgFactory.createElement(\"svg:g\");\n clipGroup.setAttributeNS(null, \"clip-path\", this.current.activeClipUrl);\n this.svg.appendChild(clipGroup);\n this.current.clipGroup = clipGroup;\n }\n return this.current.clipGroup;\n }\n\n /**\n * @private\n */\n _ensureTransformGroup() {\n if (!this.tgrp) {\n this.tgrp = this.svgFactory.createElement(\"svg:g\");\n this.tgrp.setAttributeNS(null, \"transform\", pm(this.transformMatrix));\n if (this.current.activeClipUrl) {\n this._ensureClipGroup().appendChild(this.tgrp);\n } else {\n this.svg.appendChild(this.tgrp);\n }\n }\n return this.tgrp;\n }\n };\n}\n\nexport { SVGGraphics };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* globals __non_webpack_require__ */\n\nimport {\n AbortException,\n assert,\n createPromiseCapability,\n MissingPDFException,\n} from \"../shared/util.js\";\nimport {\n extractFilenameFromHeader,\n validateRangeRequestCapabilities,\n} from \"./network_utils.js\";\n\nif (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"MOZCENTRAL\")) {\n throw new Error(\n 'Module \"./node_stream.js\" shall not be used with MOZCENTRAL builds.'\n );\n}\n\nconst fs = __non_webpack_require__(\"fs\");\nconst http = __non_webpack_require__(\"http\");\nconst https = __non_webpack_require__(\"https\");\nconst url = __non_webpack_require__(\"url\");\n\nconst fileUriRegex = /^file:\\/\\/\\/[a-zA-Z]:\\//;\n\nfunction parseUrl(sourceUrl) {\n const parsedUrl = url.parse(sourceUrl);\n if (parsedUrl.protocol === \"file:\" || parsedUrl.host) {\n return parsedUrl;\n }\n // Prepending 'file:///' to Windows absolute path.\n if (/^[a-z]:[/\\\\]/i.test(sourceUrl)) {\n return url.parse(`file:///${sourceUrl}`);\n }\n // Changes protocol to 'file:' if url refers to filesystem.\n if (!parsedUrl.host) {\n parsedUrl.protocol = \"file:\";\n }\n return parsedUrl;\n}\n\nclass PDFNodeStream {\n constructor(source) {\n this.source = source;\n this.url = parseUrl(source.url);\n this.isHttp =\n this.url.protocol === \"http:\" || this.url.protocol === \"https:\";\n // Check if url refers to filesystem.\n this.isFsUrl = this.url.protocol === \"file:\";\n this.httpHeaders = (this.isHttp && source.httpHeaders) || {};\n\n this._fullRequestReader = null;\n this._rangeRequestReaders = [];\n }\n\n get _progressiveDataLength() {\n return this._fullRequestReader ? this._fullRequestReader._loaded : 0;\n }\n\n getFullReader() {\n assert(\n !this._fullRequestReader,\n \"PDFNodeStream.getFullReader can only be called once.\"\n );\n this._fullRequestReader = this.isFsUrl\n ? new PDFNodeStreamFsFullReader(this)\n : new PDFNodeStreamFullReader(this);\n return this._fullRequestReader;\n }\n\n getRangeReader(start, end) {\n if (end <= this._progressiveDataLength) {\n return null;\n }\n const rangeReader = this.isFsUrl\n ? new PDFNodeStreamFsRangeReader(this, start, end)\n : new PDFNodeStreamRangeReader(this, start, end);\n this._rangeRequestReaders.push(rangeReader);\n return rangeReader;\n }\n\n cancelAllRequests(reason) {\n if (this._fullRequestReader) {\n this._fullRequestReader.cancel(reason);\n }\n\n const readers = this._rangeRequestReaders.slice(0);\n readers.forEach(function (reader) {\n reader.cancel(reason);\n });\n }\n}\n\nclass BaseFullReader {\n constructor(stream) {\n this._url = stream.url;\n this._done = false;\n this._storedError = null;\n this.onProgress = null;\n const source = stream.source;\n this._contentLength = source.length; // optional\n this._loaded = 0;\n this._filename = null;\n\n this._disableRange = source.disableRange || false;\n this._rangeChunkSize = source.rangeChunkSize;\n if (!this._rangeChunkSize && !this._disableRange) {\n this._disableRange = true;\n }\n\n this._isStreamingSupported = !source.disableStream;\n this._isRangeSupported = !source.disableRange;\n\n this._readableStream = null;\n this._readCapability = createPromiseCapability();\n this._headersCapability = createPromiseCapability();\n }\n\n get headersReady() {\n return this._headersCapability.promise;\n }\n\n get filename() {\n return this._filename;\n }\n\n get contentLength() {\n return this._contentLength;\n }\n\n get isRangeSupported() {\n return this._isRangeSupported;\n }\n\n get isStreamingSupported() {\n return this._isStreamingSupported;\n }\n\n async read() {\n await this._readCapability.promise;\n if (this._done) {\n return { value: undefined, done: true };\n }\n if (this._storedError) {\n throw this._storedError;\n }\n\n const chunk = this._readableStream.read();\n if (chunk === null) {\n this._readCapability = createPromiseCapability();\n return this.read();\n }\n this._loaded += chunk.length;\n if (this.onProgress) {\n this.onProgress({\n loaded: this._loaded,\n total: this._contentLength,\n });\n }\n // Ensure that `read()` method returns ArrayBuffer.\n const buffer = new Uint8Array(chunk).buffer;\n return { value: buffer, done: false };\n }\n\n cancel(reason) {\n // Call `this._error()` method when cancel is called\n // before _readableStream is set.\n if (!this._readableStream) {\n this._error(reason);\n return;\n }\n this._readableStream.destroy(reason);\n }\n\n _error(reason) {\n this._storedError = reason;\n this._readCapability.resolve();\n }\n\n _setReadableStream(readableStream) {\n this._readableStream = readableStream;\n readableStream.on(\"readable\", () => {\n this._readCapability.resolve();\n });\n\n readableStream.on(\"end\", () => {\n // Destroy readable to minimize resource usage.\n readableStream.destroy();\n this._done = true;\n this._readCapability.resolve();\n });\n\n readableStream.on(\"error\", reason => {\n this._error(reason);\n });\n\n // We need to stop reading when range is supported and streaming is\n // disabled.\n if (!this._isStreamingSupported && this._isRangeSupported) {\n this._error(new AbortException(\"streaming is disabled\"));\n }\n\n // Destroy ReadableStream if already in errored state.\n if (this._storedError) {\n this._readableStream.destroy(this._storedError);\n }\n }\n}\n\nclass BaseRangeReader {\n constructor(stream) {\n this._url = stream.url;\n this._done = false;\n this._storedError = null;\n this.onProgress = null;\n this._loaded = 0;\n this._readableStream = null;\n this._readCapability = createPromiseCapability();\n const source = stream.source;\n this._isStreamingSupported = !source.disableStream;\n }\n\n get isStreamingSupported() {\n return this._isStreamingSupported;\n }\n\n async read() {\n await this._readCapability.promise;\n if (this._done) {\n return { value: undefined, done: true };\n }\n if (this._storedError) {\n throw this._storedError;\n }\n\n const chunk = this._readableStream.read();\n if (chunk === null) {\n this._readCapability = createPromiseCapability();\n return this.read();\n }\n this._loaded += chunk.length;\n if (this.onProgress) {\n this.onProgress({ loaded: this._loaded });\n }\n // Ensure that `read()` method returns ArrayBuffer.\n const buffer = new Uint8Array(chunk).buffer;\n return { value: buffer, done: false };\n }\n\n cancel(reason) {\n // Call `this._error()` method when cancel is called\n // before _readableStream is set.\n if (!this._readableStream) {\n this._error(reason);\n return;\n }\n this._readableStream.destroy(reason);\n }\n\n _error(reason) {\n this._storedError = reason;\n this._readCapability.resolve();\n }\n\n _setReadableStream(readableStream) {\n this._readableStream = readableStream;\n readableStream.on(\"readable\", () => {\n this._readCapability.resolve();\n });\n\n readableStream.on(\"end\", () => {\n // Destroy readableStream to minimize resource usage.\n readableStream.destroy();\n this._done = true;\n this._readCapability.resolve();\n });\n\n readableStream.on(\"error\", reason => {\n this._error(reason);\n });\n\n // Destroy readableStream if already in errored state.\n if (this._storedError) {\n this._readableStream.destroy(this._storedError);\n }\n }\n}\n\nfunction createRequestOptions(parsedUrl, headers) {\n return {\n protocol: parsedUrl.protocol,\n auth: parsedUrl.auth,\n host: parsedUrl.hostname,\n port: parsedUrl.port,\n path: parsedUrl.path,\n method: \"GET\",\n headers,\n };\n}\n\nclass PDFNodeStreamFullReader extends BaseFullReader {\n constructor(stream) {\n super(stream);\n\n const handleResponse = response => {\n if (response.statusCode === 404) {\n const error = new MissingPDFException(`Missing PDF \"${this._url}\".`);\n this._storedError = error;\n this._headersCapability.reject(error);\n return;\n }\n this._headersCapability.resolve();\n this._setReadableStream(response);\n\n const getResponseHeader = name => {\n // Make sure that headers name are in lower case, as mentioned\n // here: https://nodejs.org/api/http.html#http_message_headers.\n return this._readableStream.headers[name.toLowerCase()];\n };\n const {\n allowRangeRequests,\n suggestedLength,\n } = validateRangeRequestCapabilities({\n getResponseHeader,\n isHttp: stream.isHttp,\n rangeChunkSize: this._rangeChunkSize,\n disableRange: this._disableRange,\n });\n\n this._isRangeSupported = allowRangeRequests;\n // Setting right content length.\n this._contentLength = suggestedLength || this._contentLength;\n\n this._filename = extractFilenameFromHeader(getResponseHeader);\n };\n\n this._request = null;\n if (this._url.protocol === \"http:\") {\n this._request = http.request(\n createRequestOptions(this._url, stream.httpHeaders),\n handleResponse\n );\n } else {\n this._request = https.request(\n createRequestOptions(this._url, stream.httpHeaders),\n handleResponse\n );\n }\n\n this._request.on(\"error\", reason => {\n this._storedError = reason;\n this._headersCapability.reject(reason);\n });\n // Note: `request.end(data)` is used to write `data` to request body\n // and notify end of request. But one should always call `request.end()`\n // even if there is no data to write -- (to notify the end of request).\n this._request.end();\n }\n}\n\nclass PDFNodeStreamRangeReader extends BaseRangeReader {\n constructor(stream, start, end) {\n super(stream);\n\n this._httpHeaders = {};\n for (const property in stream.httpHeaders) {\n const value = stream.httpHeaders[property];\n if (typeof value === \"undefined\") {\n continue;\n }\n this._httpHeaders[property] = value;\n }\n this._httpHeaders.Range = `bytes=${start}-${end - 1}`;\n\n const handleResponse = response => {\n if (response.statusCode === 404) {\n const error = new MissingPDFException(`Missing PDF \"${this._url}\".`);\n this._storedError = error;\n return;\n }\n this._setReadableStream(response);\n };\n\n this._request = null;\n if (this._url.protocol === \"http:\") {\n this._request = http.request(\n createRequestOptions(this._url, this._httpHeaders),\n handleResponse\n );\n } else {\n this._request = https.request(\n createRequestOptions(this._url, this._httpHeaders),\n handleResponse\n );\n }\n\n this._request.on(\"error\", reason => {\n this._storedError = reason;\n });\n this._request.end();\n }\n}\n\nclass PDFNodeStreamFsFullReader extends BaseFullReader {\n constructor(stream) {\n super(stream);\n\n let path = decodeURIComponent(this._url.path);\n\n // Remove the extra slash to get right path from url like `file:///C:/`\n if (fileUriRegex.test(this._url.href)) {\n path = path.replace(/^\\//, \"\");\n }\n\n fs.lstat(path, (error, stat) => {\n if (error) {\n if (error.code === \"ENOENT\") {\n error = new MissingPDFException(`Missing PDF \"${path}\".`);\n }\n this._storedError = error;\n this._headersCapability.reject(error);\n return;\n }\n // Setting right content length.\n this._contentLength = stat.size;\n\n this._setReadableStream(fs.createReadStream(path));\n this._headersCapability.resolve();\n });\n }\n}\n\nclass PDFNodeStreamFsRangeReader extends BaseRangeReader {\n constructor(stream, start, end) {\n super(stream);\n\n let path = decodeURIComponent(this._url.path);\n\n // Remove the extra slash to get right path from url like `file:///C:/`\n if (fileUriRegex.test(this._url.href)) {\n path = path.replace(/^\\//, \"\");\n }\n\n this._setReadableStream(fs.createReadStream(path, { start, end: end - 1 }));\n }\n}\n\nexport { PDFNodeStream };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n assert,\n MissingPDFException,\n UnexpectedResponseException,\n} from \"../shared/util.js\";\nimport { getFilenameFromContentDispositionHeader } from \"./content_disposition.js\";\n\nfunction validateRangeRequestCapabilities({\n getResponseHeader,\n isHttp,\n rangeChunkSize,\n disableRange,\n}) {\n assert(rangeChunkSize > 0, \"Range chunk size must be larger than zero\");\n const returnValues = {\n allowRangeRequests: false,\n suggestedLength: undefined,\n };\n\n const length = parseInt(getResponseHeader(\"Content-Length\"), 10);\n if (!Number.isInteger(length)) {\n return returnValues;\n }\n\n returnValues.suggestedLength = length;\n\n if (length <= 2 * rangeChunkSize) {\n // The file size is smaller than the size of two chunks, so it does not\n // make any sense to abort the request and retry with a range request.\n return returnValues;\n }\n\n if (disableRange || !isHttp) {\n return returnValues;\n }\n if (getResponseHeader(\"Accept-Ranges\") !== \"bytes\") {\n return returnValues;\n }\n\n const contentEncoding = getResponseHeader(\"Content-Encoding\") || \"identity\";\n if (contentEncoding !== \"identity\") {\n return returnValues;\n }\n\n returnValues.allowRangeRequests = true;\n return returnValues;\n}\n\nfunction extractFilenameFromHeader(getResponseHeader) {\n const contentDisposition = getResponseHeader(\"Content-Disposition\");\n if (contentDisposition) {\n let filename = getFilenameFromContentDispositionHeader(contentDisposition);\n if (filename.includes(\"%\")) {\n try {\n filename = decodeURIComponent(filename);\n } catch (ex) {}\n }\n if (/\\.pdf$/i.test(filename)) {\n return filename;\n }\n }\n return null;\n}\n\nfunction createResponseStatusError(status, url) {\n if (status === 404 || (status === 0 && url.startsWith(\"file:\"))) {\n return new MissingPDFException('Missing PDF \"' + url + '\".');\n }\n return new UnexpectedResponseException(\n \"Unexpected server response (\" +\n status +\n ') while retrieving PDF \"' +\n url +\n '\".',\n status\n );\n}\n\nfunction validateResponseStatus(status) {\n return status === 200 || status === 206;\n}\n\nexport {\n createResponseStatusError,\n extractFilenameFromHeader,\n validateRangeRequestCapabilities,\n validateResponseStatus,\n};\n","/* Copyright 2017 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n// This getFilenameFromContentDispositionHeader function is adapted from\n// https://github.com/Rob--W/open-in-browser/blob/7e2e35a38b8b4e981b11da7b2f01df0149049e92/extension/content-disposition.js\n// with the following changes:\n// - Modified to conform to PDF.js's coding style.\n// - Support UTF-8 decoding when TextDecoder is unsupported.\n// - Move return to the end of the function to prevent Babel from dropping the\n// function declarations.\n\n/**\n * Extract file name from the Content-Disposition HTTP response header.\n *\n * @param {string} contentDisposition\n * @returns {string} Filename, if found in the Content-Disposition header.\n */\nfunction getFilenameFromContentDispositionHeader(contentDisposition) {\n let needsEncodingFixup = true;\n\n // filename*=ext-value (\"ext-value\" from RFC 5987, referenced by RFC 6266).\n let tmp = toParamRegExp(\"filename\\\\*\", \"i\").exec(contentDisposition);\n if (tmp) {\n tmp = tmp[1];\n let filename = rfc2616unquote(tmp);\n filename = unescape(filename);\n filename = rfc5987decode(filename);\n filename = rfc2047decode(filename);\n return fixupEncoding(filename);\n }\n\n // Continuations (RFC 2231 section 3, referenced by RFC 5987 section 3.1).\n // filename*n*=part\n // filename*n=part\n tmp = rfc2231getparam(contentDisposition);\n if (tmp) {\n // RFC 2047, section\n const filename = rfc2047decode(tmp);\n return fixupEncoding(filename);\n }\n\n // filename=value (RFC 5987, section 4.1).\n tmp = toParamRegExp(\"filename\", \"i\").exec(contentDisposition);\n if (tmp) {\n tmp = tmp[1];\n let filename = rfc2616unquote(tmp);\n filename = rfc2047decode(filename);\n return fixupEncoding(filename);\n }\n\n // After this line there are only function declarations. We cannot put\n // \"return\" here for readability because babel would then drop the function\n // declarations...\n function toParamRegExp(attributePattern, flags) {\n return new RegExp(\n \"(?:^|;)\\\\s*\" +\n attributePattern +\n \"\\\\s*=\\\\s*\" +\n // Captures: value = token | quoted-string\n // (RFC 2616, section 3.6 and referenced by RFC 6266 4.1)\n \"(\" +\n '[^\";\\\\s][^;\\\\s]*' +\n \"|\" +\n '\"(?:[^\"\\\\\\\\]|\\\\\\\\\"?)+\"?' +\n \")\",\n flags\n );\n }\n function textdecode(encoding, value) {\n if (encoding) {\n if (!/^[\\x00-\\xFF]+$/.test(value)) {\n return value;\n }\n try {\n const decoder = new TextDecoder(encoding, { fatal: true });\n const bytes = Array.from(value, function (ch) {\n return ch.charCodeAt(0) & 0xff;\n });\n value = decoder.decode(new Uint8Array(bytes));\n needsEncodingFixup = false;\n } catch (e) {\n // TextDecoder constructor threw - unrecognized encoding.\n // Or TextDecoder API is not available (in IE / Edge).\n if (/^utf-?8$/i.test(encoding)) {\n // UTF-8 is commonly used, try to support it in another way:\n try {\n value = decodeURIComponent(escape(value));\n needsEncodingFixup = false;\n } catch (err) {}\n }\n }\n }\n return value;\n }\n function fixupEncoding(value) {\n if (needsEncodingFixup && /[\\x80-\\xff]/.test(value)) {\n // Maybe multi-byte UTF-8.\n value = textdecode(\"utf-8\", value);\n if (needsEncodingFixup) {\n // Try iso-8859-1 encoding.\n value = textdecode(\"iso-8859-1\", value);\n }\n }\n return value;\n }\n function rfc2231getparam(contentDispositionStr) {\n const matches = [];\n let match;\n // Iterate over all filename*n= and filename*n*= with n being an integer\n // of at least zero. Any non-zero number must not start with '0'.\n const iter = toParamRegExp(\"filename\\\\*((?!0\\\\d)\\\\d+)(\\\\*?)\", \"ig\");\n while ((match = iter.exec(contentDispositionStr)) !== null) {\n let [, n, quot, part] = match; // eslint-disable-line prefer-const\n n = parseInt(n, 10);\n if (n in matches) {\n // Ignore anything after the invalid second filename*0.\n if (n === 0) {\n break;\n }\n continue;\n }\n matches[n] = [quot, part];\n }\n const parts = [];\n for (let n = 0; n < matches.length; ++n) {\n if (!(n in matches)) {\n // Numbers must be consecutive. Truncate when there is a hole.\n break;\n }\n let [quot, part] = matches[n]; // eslint-disable-line prefer-const\n part = rfc2616unquote(part);\n if (quot) {\n part = unescape(part);\n if (n === 0) {\n part = rfc5987decode(part);\n }\n }\n parts.push(part);\n }\n return parts.join(\"\");\n }\n function rfc2616unquote(value) {\n if (value.startsWith('\"')) {\n const parts = value.slice(1).split('\\\\\"');\n // Find the first unescaped \" and terminate there.\n for (let i = 0; i < parts.length; ++i) {\n const quotindex = parts[i].indexOf('\"');\n if (quotindex !== -1) {\n parts[i] = parts[i].slice(0, quotindex);\n parts.length = i + 1; // Truncates and stop the iteration.\n }\n parts[i] = parts[i].replace(/\\\\(.)/g, \"$1\");\n }\n value = parts.join('\"');\n }\n return value;\n }\n function rfc5987decode(extvalue) {\n // Decodes \"ext-value\" from RFC 5987.\n const encodingend = extvalue.indexOf(\"'\");\n if (encodingend === -1) {\n // Some servers send \"filename*=\" without encoding 'language' prefix,\n // e.g. in https://github.com/Rob--W/open-in-browser/issues/26\n // Let's accept the value like Firefox (57) (Chrome 62 rejects it).\n return extvalue;\n }\n const encoding = extvalue.slice(0, encodingend);\n const langvalue = extvalue.slice(encodingend + 1);\n // Ignore language (RFC 5987 section 3.2.1, and RFC 6266 section 4.1 ).\n const value = langvalue.replace(/^[^']*'/, \"\");\n return textdecode(encoding, value);\n }\n function rfc2047decode(value) {\n // RFC 2047-decode the result. Firefox tried to drop support for it, but\n // backed out because some servers use it - https://bugzil.la/875615\n // Firefox's condition for decoding is here: https://searchfox.org/mozilla-central/rev/4a590a5a15e35d88a3b23dd6ac3c471cf85b04a8/netwerk/mime/nsMIMEHeaderParamImpl.cpp#742-748\n\n // We are more strict and only recognize RFC 2047-encoding if the value\n // starts with \"=?\", since then it is likely that the full value is\n // RFC 2047-encoded.\n\n // Firefox also decodes words even where RFC 2047 section 5 states:\n // \"An 'encoded-word' MUST NOT appear within a 'quoted-string'.\"\n if (!value.startsWith(\"=?\") || /[\\x00-\\x19\\x80-\\xff]/.test(value)) {\n return value;\n }\n // RFC 2047, section 2.4\n // encoded-word = \"=?\" charset \"?\" encoding \"?\" encoded-text \"?=\"\n // charset = token (but let's restrict to characters that denote a\n // possibly valid encoding).\n // encoding = q or b\n // encoded-text = any printable ASCII character other than ? or space.\n // ... but Firefox permits ? and space.\n return value.replace(\n /=\\?([\\w-]*)\\?([QqBb])\\?((?:[^?]|\\?(?!=))*)\\?=/g,\n function (matches, charset, encoding, text) {\n if (encoding === \"q\" || encoding === \"Q\") {\n // RFC 2047 section 4.2.\n text = text.replace(/_/g, \" \");\n text = text.replace(/=([0-9a-fA-F]{2})/g, function (match, hex) {\n return String.fromCharCode(parseInt(hex, 16));\n });\n return textdecode(charset, text);\n } // else encoding is b or B - base64 (RFC 2047 section 4.1)\n try {\n text = atob(text);\n } catch (e) {}\n return textdecode(charset, text);\n }\n );\n }\n\n return \"\";\n}\n\nexport { getFilenameFromContentDispositionHeader };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error */\n\nimport {\n assert,\n createPromiseCapability,\n stringToBytes,\n} from \"../shared/util.js\";\nimport {\n createResponseStatusError,\n extractFilenameFromHeader,\n validateRangeRequestCapabilities,\n} from \"./network_utils.js\";\n\nif (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"MOZCENTRAL\")) {\n throw new Error(\n 'Module \"./network.js\" shall not be used with MOZCENTRAL builds.'\n );\n}\n\nconst OK_RESPONSE = 200;\nconst PARTIAL_CONTENT_RESPONSE = 206;\n\nfunction getArrayBuffer(xhr) {\n const data = xhr.response;\n if (typeof data !== \"string\") {\n return data;\n }\n const array = stringToBytes(data);\n return array.buffer;\n}\n\nclass NetworkManager {\n constructor(url, args) {\n this.url = url;\n args = args || {};\n this.isHttp = /^https?:/i.test(url);\n this.httpHeaders = (this.isHttp && args.httpHeaders) || {};\n this.withCredentials = args.withCredentials || false;\n this.getXhr =\n args.getXhr ||\n function NetworkManager_getXhr() {\n return new XMLHttpRequest();\n };\n\n this.currXhrId = 0;\n this.pendingRequests = Object.create(null);\n }\n\n requestRange(begin, end, listeners) {\n const args = {\n begin,\n end,\n };\n for (const prop in listeners) {\n args[prop] = listeners[prop];\n }\n return this.request(args);\n }\n\n requestFull(listeners) {\n return this.request(listeners);\n }\n\n request(args) {\n const xhr = this.getXhr();\n const xhrId = this.currXhrId++;\n const pendingRequest = (this.pendingRequests[xhrId] = {\n xhr,\n });\n\n xhr.open(\"GET\", this.url);\n xhr.withCredentials = this.withCredentials;\n for (const property in this.httpHeaders) {\n const value = this.httpHeaders[property];\n if (typeof value === \"undefined\") {\n continue;\n }\n xhr.setRequestHeader(property, value);\n }\n if (this.isHttp && \"begin\" in args && \"end\" in args) {\n xhr.setRequestHeader(\"Range\", `bytes=${args.begin}-${args.end - 1}`);\n pendingRequest.expectedStatus = PARTIAL_CONTENT_RESPONSE;\n } else {\n pendingRequest.expectedStatus = OK_RESPONSE;\n }\n xhr.responseType = \"arraybuffer\";\n\n if (args.onError) {\n xhr.onerror = function (evt) {\n args.onError(xhr.status);\n };\n }\n xhr.onreadystatechange = this.onStateChange.bind(this, xhrId);\n xhr.onprogress = this.onProgress.bind(this, xhrId);\n\n pendingRequest.onHeadersReceived = args.onHeadersReceived;\n pendingRequest.onDone = args.onDone;\n pendingRequest.onError = args.onError;\n pendingRequest.onProgress = args.onProgress;\n\n xhr.send(null);\n\n return xhrId;\n }\n\n onProgress(xhrId, evt) {\n const pendingRequest = this.pendingRequests[xhrId];\n if (!pendingRequest) {\n // Maybe abortRequest was called...\n return;\n }\n\n if (pendingRequest.onProgress) {\n pendingRequest.onProgress(evt);\n }\n }\n\n onStateChange(xhrId, evt) {\n const pendingRequest = this.pendingRequests[xhrId];\n if (!pendingRequest) {\n // Maybe abortRequest was called...\n return;\n }\n\n const xhr = pendingRequest.xhr;\n if (xhr.readyState >= 2 && pendingRequest.onHeadersReceived) {\n pendingRequest.onHeadersReceived();\n delete pendingRequest.onHeadersReceived;\n }\n\n if (xhr.readyState !== 4) {\n return;\n }\n\n if (!(xhrId in this.pendingRequests)) {\n // The XHR request might have been aborted in onHeadersReceived()\n // callback, in which case we should abort request.\n return;\n }\n\n delete this.pendingRequests[xhrId];\n\n // Success status == 0 can be on ftp, file and other protocols.\n if (xhr.status === 0 && this.isHttp) {\n if (pendingRequest.onError) {\n pendingRequest.onError(xhr.status);\n }\n return;\n }\n const xhrStatus = xhr.status || OK_RESPONSE;\n\n // From http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35.2:\n // \"A server MAY ignore the Range header\". This means it's possible to\n // get a 200 rather than a 206 response from a range request.\n const ok_response_on_range_request =\n xhrStatus === OK_RESPONSE &&\n pendingRequest.expectedStatus === PARTIAL_CONTENT_RESPONSE;\n\n if (\n !ok_response_on_range_request &&\n xhrStatus !== pendingRequest.expectedStatus\n ) {\n if (pendingRequest.onError) {\n pendingRequest.onError(xhr.status);\n }\n return;\n }\n\n const chunk = getArrayBuffer(xhr);\n if (xhrStatus === PARTIAL_CONTENT_RESPONSE) {\n const rangeHeader = xhr.getResponseHeader(\"Content-Range\");\n const matches = /bytes (\\d+)-(\\d+)\\/(\\d+)/.exec(rangeHeader);\n pendingRequest.onDone({\n begin: parseInt(matches[1], 10),\n chunk,\n });\n } else if (chunk) {\n pendingRequest.onDone({\n begin: 0,\n chunk,\n });\n } else if (pendingRequest.onError) {\n pendingRequest.onError(xhr.status);\n }\n }\n\n hasPendingRequests() {\n for (const xhrId in this.pendingRequests) {\n return true;\n }\n return false;\n }\n\n getRequestXhr(xhrId) {\n return this.pendingRequests[xhrId].xhr;\n }\n\n isPendingRequest(xhrId) {\n return xhrId in this.pendingRequests;\n }\n\n abortAllRequests() {\n for (const xhrId in this.pendingRequests) {\n this.abortRequest(xhrId | 0);\n }\n }\n\n abortRequest(xhrId) {\n const xhr = this.pendingRequests[xhrId].xhr;\n delete this.pendingRequests[xhrId];\n xhr.abort();\n }\n}\n\n/** @implements {IPDFStream} */\nclass PDFNetworkStream {\n constructor(source) {\n this._source = source;\n this._manager = new NetworkManager(source.url, {\n httpHeaders: source.httpHeaders,\n withCredentials: source.withCredentials,\n });\n this._rangeChunkSize = source.rangeChunkSize;\n this._fullRequestReader = null;\n this._rangeRequestReaders = [];\n }\n\n _onRangeRequestReaderClosed(reader) {\n const i = this._rangeRequestReaders.indexOf(reader);\n if (i >= 0) {\n this._rangeRequestReaders.splice(i, 1);\n }\n }\n\n getFullReader() {\n assert(\n !this._fullRequestReader,\n \"PDFNetworkStream.getFullReader can only be called once.\"\n );\n this._fullRequestReader = new PDFNetworkStreamFullRequestReader(\n this._manager,\n this._source\n );\n return this._fullRequestReader;\n }\n\n getRangeReader(begin, end) {\n const reader = new PDFNetworkStreamRangeRequestReader(\n this._manager,\n begin,\n end\n );\n reader.onClosed = this._onRangeRequestReaderClosed.bind(this);\n this._rangeRequestReaders.push(reader);\n return reader;\n }\n\n cancelAllRequests(reason) {\n if (this._fullRequestReader) {\n this._fullRequestReader.cancel(reason);\n }\n const readers = this._rangeRequestReaders.slice(0);\n readers.forEach(function (reader) {\n reader.cancel(reason);\n });\n }\n}\n\n/** @implements {IPDFStreamReader} */\nclass PDFNetworkStreamFullRequestReader {\n constructor(manager, source) {\n this._manager = manager;\n\n const args = {\n onHeadersReceived: this._onHeadersReceived.bind(this),\n onDone: this._onDone.bind(this),\n onError: this._onError.bind(this),\n onProgress: this._onProgress.bind(this),\n };\n this._url = source.url;\n this._fullRequestId = manager.requestFull(args);\n this._headersReceivedCapability = createPromiseCapability();\n this._disableRange = source.disableRange || false;\n this._contentLength = source.length; // Optional\n this._rangeChunkSize = source.rangeChunkSize;\n if (!this._rangeChunkSize && !this._disableRange) {\n this._disableRange = true;\n }\n\n this._isStreamingSupported = false;\n this._isRangeSupported = false;\n\n this._cachedChunks = [];\n this._requests = [];\n this._done = false;\n this._storedError = undefined;\n this._filename = null;\n\n this.onProgress = null;\n }\n\n _onHeadersReceived() {\n const fullRequestXhrId = this._fullRequestId;\n const fullRequestXhr = this._manager.getRequestXhr(fullRequestXhrId);\n\n const getResponseHeader = name => {\n return fullRequestXhr.getResponseHeader(name);\n };\n const {\n allowRangeRequests,\n suggestedLength,\n } = validateRangeRequestCapabilities({\n getResponseHeader,\n isHttp: this._manager.isHttp,\n rangeChunkSize: this._rangeChunkSize,\n disableRange: this._disableRange,\n });\n\n if (allowRangeRequests) {\n this._isRangeSupported = true;\n }\n // Setting right content length.\n this._contentLength = suggestedLength || this._contentLength;\n\n this._filename = extractFilenameFromHeader(getResponseHeader);\n\n if (this._isRangeSupported) {\n // NOTE: by cancelling the full request, and then issuing range\n // requests, there will be an issue for sites where you can only\n // request the pdf once. However, if this is the case, then the\n // server should not be returning that it can support range requests.\n this._manager.abortRequest(fullRequestXhrId);\n }\n\n this._headersReceivedCapability.resolve();\n }\n\n _onDone(args) {\n if (args) {\n if (this._requests.length > 0) {\n const requestCapability = this._requests.shift();\n requestCapability.resolve({ value: args.chunk, done: false });\n } else {\n this._cachedChunks.push(args.chunk);\n }\n }\n this._done = true;\n if (this._cachedChunks.length > 0) {\n return;\n }\n this._requests.forEach(function (requestCapability) {\n requestCapability.resolve({ value: undefined, done: true });\n });\n this._requests = [];\n }\n\n _onError(status) {\n const url = this._url;\n const exception = createResponseStatusError(status, url);\n this._storedError = exception;\n this._headersReceivedCapability.reject(exception);\n this._requests.forEach(function (requestCapability) {\n requestCapability.reject(exception);\n });\n this._requests = [];\n this._cachedChunks = [];\n }\n\n _onProgress(data) {\n if (this.onProgress) {\n this.onProgress({\n loaded: data.loaded,\n total: data.lengthComputable ? data.total : this._contentLength,\n });\n }\n }\n\n get filename() {\n return this._filename;\n }\n\n get isRangeSupported() {\n return this._isRangeSupported;\n }\n\n get isStreamingSupported() {\n return this._isStreamingSupported;\n }\n\n get contentLength() {\n return this._contentLength;\n }\n\n get headersReady() {\n return this._headersReceivedCapability.promise;\n }\n\n async read() {\n if (this._storedError) {\n throw this._storedError;\n }\n if (this._cachedChunks.length > 0) {\n const chunk = this._cachedChunks.shift();\n return { value: chunk, done: false };\n }\n if (this._done) {\n return { value: undefined, done: true };\n }\n const requestCapability = createPromiseCapability();\n this._requests.push(requestCapability);\n return requestCapability.promise;\n }\n\n cancel(reason) {\n this._done = true;\n this._headersReceivedCapability.reject(reason);\n this._requests.forEach(function (requestCapability) {\n requestCapability.resolve({ value: undefined, done: true });\n });\n this._requests = [];\n if (this._manager.isPendingRequest(this._fullRequestId)) {\n this._manager.abortRequest(this._fullRequestId);\n }\n this._fullRequestReader = null;\n }\n}\n\n/** @implements {IPDFStreamRangeReader} */\nclass PDFNetworkStreamRangeRequestReader {\n constructor(manager, begin, end) {\n this._manager = manager;\n const args = {\n onDone: this._onDone.bind(this),\n onProgress: this._onProgress.bind(this),\n };\n this._requestId = manager.requestRange(begin, end, args);\n this._requests = [];\n this._queuedChunk = null;\n this._done = false;\n\n this.onProgress = null;\n this.onClosed = null;\n }\n\n _close() {\n if (this.onClosed) {\n this.onClosed(this);\n }\n }\n\n _onDone(data) {\n const chunk = data.chunk;\n if (this._requests.length > 0) {\n const requestCapability = this._requests.shift();\n requestCapability.resolve({ value: chunk, done: false });\n } else {\n this._queuedChunk = chunk;\n }\n this._done = true;\n this._requests.forEach(function (requestCapability) {\n requestCapability.resolve({ value: undefined, done: true });\n });\n this._requests = [];\n this._close();\n }\n\n _onProgress(evt) {\n if (!this.isStreamingSupported && this.onProgress) {\n this.onProgress({\n loaded: evt.loaded,\n });\n }\n }\n\n get isStreamingSupported() {\n return false;\n }\n\n async read() {\n if (this._queuedChunk !== null) {\n const chunk = this._queuedChunk;\n this._queuedChunk = null;\n return { value: chunk, done: false };\n }\n if (this._done) {\n return { value: undefined, done: true };\n }\n const requestCapability = createPromiseCapability();\n this._requests.push(requestCapability);\n return requestCapability.promise;\n }\n\n cancel(reason) {\n this._done = true;\n this._requests.forEach(function (requestCapability) {\n requestCapability.resolve({ value: undefined, done: true });\n });\n this._requests = [];\n if (this._manager.isPendingRequest(this._requestId)) {\n this._manager.abortRequest(this._requestId);\n }\n this._close();\n }\n}\n\nexport { PDFNetworkStream };\n","/* Copyright 2012 Mozilla Foundation\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n/* eslint no-var: error */\n\nimport {\n AbortException,\n assert,\n createPromiseCapability,\n} from \"../shared/util.js\";\nimport {\n createResponseStatusError,\n extractFilenameFromHeader,\n validateRangeRequestCapabilities,\n validateResponseStatus,\n} from \"./network_utils.js\";\n\nif (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"MOZCENTRAL\")) {\n throw new Error(\n 'Module \"./fetch_stream.js\" shall not be used with MOZCENTRAL builds.'\n );\n}\n\nfunction createFetchOptions(headers, withCredentials, abortController) {\n return {\n method: \"GET\",\n headers,\n signal: abortController && abortController.signal,\n mode: \"cors\",\n credentials: withCredentials ? \"include\" : \"same-origin\",\n redirect: \"follow\",\n };\n}\n\nfunction createHeaders(httpHeaders) {\n const headers = new Headers();\n for (const property in httpHeaders) {\n const value = httpHeaders[property];\n if (typeof value === \"undefined\") {\n continue;\n }\n headers.append(property, value);\n }\n return headers;\n}\n\n/** @implements {IPDFStream} */\nclass PDFFetchStream {\n constructor(source) {\n this.source = source;\n this.isHttp = /^https?:/i.test(source.url);\n this.httpHeaders = (this.isHttp && source.httpHeaders) || {};\n\n this._fullRequestReader = null;\n this._rangeRequestReaders = [];\n }\n\n get _progressiveDataLength() {\n return this._fullRequestReader ? this._fullRequestReader._loaded : 0;\n }\n\n getFullReader() {\n assert(\n !this._fullRequestReader,\n \"PDFFetchStream.getFullReader can only be called once.\"\n );\n this._fullRequestReader = new PDFFetchStreamReader(this);\n return this._fullRequestReader;\n }\n\n getRangeReader(begin, end) {\n if (end <= this._progressiveDataLength) {\n return null;\n }\n const reader = new PDFFetchStreamRangeReader(this, begin, end);\n this._rangeRequestReaders.push(reader);\n return reader;\n }\n\n cancelAllRequests(reason) {\n if (this._fullRequestReader) {\n this._fullRequestReader.cancel(reason);\n }\n const readers = this._rangeRequestReaders.slice(0);\n readers.forEach(function (reader) {\n reader.cancel(reason);\n });\n }\n}\n\n/** @implements {IPDFStreamReader} */\nclass PDFFetchStreamReader {\n constructor(stream) {\n this._stream = stream;\n this._reader = null;\n this._loaded = 0;\n this._filename = null;\n const source = stream.source;\n this._withCredentials = source.withCredentials || false;\n this._contentLength = source.length;\n this._headersCapability = createPromiseCapability();\n this._disableRange = source.disableRange || false;\n this._rangeChunkSize = source.rangeChunkSize;\n if (!this._rangeChunkSize && !this._disableRange) {\n this._disableRange = true;\n }\n\n if (typeof AbortController !== \"undefined\") {\n this._abortController = new AbortController();\n }\n this._isStreamingSupported = !source.disableStream;\n this._isRangeSupported = !source.disableRange;\n\n this._headers = createHeaders(this._stream.httpHeaders);\n\n const url = source.url;\n fetch(\n url,\n createFetchOptions(\n this._headers,\n this._withCredentials,\n this._abortController\n )\n )\n .then(response => {\n if (!validateResponseStatus(response.status)) {\n throw createResponseStatusError(response.status, url);\n }\n this._reader = response.body.getReader();\n this._headersCapability.resolve();\n\n const getResponseHeader = name => {\n return response.headers.get(name);\n };\n const {\n allowRangeRequests,\n suggestedLength,\n } = validateRangeRequestCapabilities({\n getResponseHeader,\n isHttp: this._stream.isHttp,\n rangeChunkSize: this._rangeChunkSize,\n disableRange: this._disableRange,\n });\n\n this._isRangeSupported = allowRangeRequests;\n // Setting right content length.\n this._contentLength = suggestedLength || this._contentLength;\n\n this._filename = extractFilenameFromHeader(getResponseHeader);\n\n // We need to stop reading when range is supported and streaming is\n // disabled.\n if (!this._isStreamingSupported && this._isRangeSupported) {\n this.cancel(new AbortException(\"Streaming is disabled.\"));\n }\n })\n .catch(this._headersCapability.reject);\n\n this.onProgress = null;\n }\n\n get headersReady() {\n return this._headersCapability.promise;\n }\n\n get filename() {\n return this._filename;\n }\n\n get contentLength() {\n return this._contentLength;\n }\n\n get isRangeSupported() {\n return this._isRangeSupported;\n }\n\n get isStreamingSupported() {\n return this._isStreamingSupported;\n }\n\n async read() {\n await this._headersCapability.promise;\n const { value, done } = await this._reader.read();\n if (done) {\n return { value, done };\n }\n this._loaded += value.byteLength;\n if (this.onProgress) {\n this.onProgress({\n loaded: this._loaded,\n total: this._contentLength,\n });\n }\n const buffer = new Uint8Array(value).buffer;\n return { value: buffer, done: false };\n }\n\n cancel(reason) {\n if (this._reader) {\n this._reader.cancel(reason);\n }\n if (this._abortController) {\n this._abortController.abort();\n }\n }\n}\n\n/** @implements {IPDFStreamRangeReader} */\nclass PDFFetchStreamRangeReader {\n constructor(stream, begin, end) {\n this._stream = stream;\n this._reader = null;\n this._loaded = 0;\n const source = stream.source;\n this._withCredentials = source.withCredentials || false;\n this._readCapability = createPromiseCapability();\n this._isStreamingSupported = !source.disableStream;\n\n if (typeof AbortController !== \"undefined\") {\n this._abortController = new AbortController();\n }\n\n this._headers = createHeaders(this._stream.httpHeaders);\n this._headers.append(\"Range\", `bytes=${begin}-${end - 1}`);\n\n const url = source.url;\n fetch(\n url,\n createFetchOptions(\n this._headers,\n this._withCredentials,\n this._abortController\n )\n ).then(response => {\n if (!validateResponseStatus(response.status)) {\n throw createResponseStatusError(response.status, url);\n }\n this._readCapability.resolve();\n this._reader = response.body.getReader();\n });\n\n this.onProgress = null;\n }\n\n get isStreamingSupported() {\n return this._isStreamingSupported;\n }\n\n async read() {\n await this._readCapability.promise;\n const { value, done } = await this._reader.read();\n if (done) {\n return { value, done };\n }\n this._loaded += value.byteLength;\n if (this.onProgress) {\n this.onProgress({ loaded: this._loaded });\n }\n const buffer = new Uint8Array(value).buffer;\n return { value: buffer, done: false };\n }\n\n cancel(reason) {\n if (this._reader) {\n this._reader.cancel(reason);\n }\n if (this._abortController) {\n this._abortController.abort();\n }\n }\n}\n\nexport { PDFFetchStream };\n"],"sourceRoot":""}
