{"version":3,"sources":["webpack://pdfjs-dist/build/pdf/webpack/universalModuleDefinition","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/node_utils.js","webpack://pdfjs-dist/build/pdf/src/display/annotation_storage.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/shared/xml_parser.js","webpack://pdfjs-dist/build/pdf/src/display/optional_content_config.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/shared/scripting_utils.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","webpack://pdfjs-dist/build/pdf/webpack/bootstrap","webpack://pdfjs-dist/build/pdf/webpack/startup"],"names":["pdfjsVersion","pdfjsBuild","require","PDFNodeStream","setPDFNetworkStreamFactory","params","PDFNetworkStream","PDFFetchStream","isValidFetchUrl","DEFAULT_LINK_REL","SVG_NS","constructor","unreachable","create","reset","canvasAndContext","width","height","destroy","ownerDocument","globalThis","canvas","context","baseUrl","isCompressed","url","compressionType","CMapCompressionType","reason","_fetchData","isFetchSupported","document","response","cMapData","stringToBytes","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","removeScriptElement","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","AnnotationActionEventType","E","X","D","U","Fo","Bl","PO","PC","PV","PI","K","F","V","C","DocumentActionEventType","WC","WS","DS","WP","DP","PageActionEventType","O","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","errorMarkedContent","PasswordResponses","NEED_PASSWORD","INCORRECT_PASSWORD","verbosity","Number","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","hexNumbers","Array","n","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","match","buf","ii","char","decodeURIComponent","escape","unescape","encodeURIComponent","arr1","arr2","element","date","buffer","capability","isSettled","get","createObjectURL","digits","forceDataSchema","URL","blob","type","b1","b2","b3","d1","d2","d3","d4","XMLEntities","entity","isNodeJS","process","DEFAULT_RANGE_CHUNK_SIZE","RENDERING_CANCELLED_TIMEOUT","DefaultCanvasFactory","DefaultCMapReaderFactory","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","getAttachments","getJavaScript","getJSActions","getOutline","getOptionalContentConfig","getPermissions","getMetadata","getMarkInfo","getData","getDownloadInfo","getStats","cleanup","saveDocument","getFieldObjects","hasJSActions","getCalculationOrderIds","pdfBug","getViewport","getAnnotations","intent","render","enableWebGL","renderInteractiveForms","imageLayer","canvasFactory","background","annotationStorage","optionalContentConfigPromise","renderingIntent","intentState","clearTimeout","canvasFactoryInstance","webGLContext","enable","fnArray","argsArray","lastChunk","pageIndex","complete","error","internalRenderTask","callback","objs","commonObjs","operatorList","useRequestAnimationFrame","renderTask","getOperatorList","opListTask","streamTextContent","normalizeWhitespace","disableCombineTextItems","TEXT_CONTENT_CHUNK_SIZE","combineTextItems","highWaterMark","size","textContent","getTextContent","readableStream","reader","pump","items","styles","_destroy","waitOn","force","resetStats","_tryCleanup","renderTasks","_startRenderPage","_renderPageChunk","operatorListChunk","_pumpOperatorList","args","_abortOperatorList","curIntentState","defer","postMessage","cloned","transfers","desc","cloneValue","e","addEventListener","removeEventListener","terminate","pdfWorkerPorts","isWorkerDisabled","nextFakeWorkerId","fallbackWorkerSrc","pdfjsFilePath","deprecated","mainWorkerMessageHandler","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","annotationStorageResetModified","pdfDocument","setupMessageHandler","evt","loaded","total","sink","readyReason","headersCapability","fullReader","isStreamingSupported","isRangeSupported","contentLength","rangeReader","pdfInfo","ex","msg","exception","updatePassword","exportedError","exportedData","fontRegistry","registerFont","pageProxy","MAX_IMAGE_SIZE_TO_STORE","imageData","fetched","builtInCMap","_onUnsupportedFeature","pageNumber","promise","pageInfo","numPages","filename","getDocJSActions","getPageJSActions","results","metadata","contentDispositionFilename","startCleanup","cleanupSuccessful","_ensureObj","resolved","obj","has","clear","cancel","InternalRenderTask","canvasInRendering","initializeGraphics","transparency","operatorListChanged","_continue","_scheduleNext","version","build","addNativeFontFace","insertRule","styleElement","styleSheet","nativeFontFace","featureId","rule","_queueLoadingCallback","_prepareFontLoadEvent","FontLoader","requests","nextRequestId","supported","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","NodeCanvasFactory","NodeCMapReaderFactory","Canvas","__non_webpack_require__","fs","getOrCreateValue","setValue","modified","getAll","objectFromEntries","_setModified","resetModified","compatibilityParams","MIN_FONT_SIZE","MAX_FONT_SIZE","MAX_GROUP_SIZE","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","elem","mask","count","j","j0","sum","steps","outlines","coords","p0","step","pp","drawOutline","k","kk","o","l","ll","CanvasExtraState","setCurrentPoint","CanvasGraphics","EXECUTION_TIME","EXECUTION_STEPS","transferMaps","partialChunkHeight","fullChunks","totalChunks","chunkImgData","srcPos","dest","transferMapRed","transferMapGreen","transferMapBlue","transferMapGray","srcLength","dest32","dest32DataLength","fullSrcDiff","white","black","thisChunkHeight","destPos","srcDiff","kEnd","kEndUnrolled","srcByte","hasTransferMaps","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","lineWidth","scaledLineWidth","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","resetLineWidthToOne","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","skewX","skewY","positions","images","image","objId","map","w","h","widthScale","heightScale","imgToPaint","tmpCanvas","tmpCtx","putBinaryImageData","paintWidth","paintHeight","tmpCanvasId","newWidth","newHeight","position","left","top","entry","visible","tag","getSinglePixelWidth","absDet","sqNorm1","sqNorm2","pixelHeight","getCanvasPosition","isContentVisible","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","lowerCaseName","xmlDocument","_repair","chars","_getSequence","node","_getCreators","seqNode","authors","_parse","rdf","getRaw","XMLParserErrorCode","NoError","EndOfDocument","UnterminatedCdat","UnterminatedXmlDeclaration","UnterminatedDoctypeDeclaration","UnterminatedComment","MalformedElement","OutOfMemory","UnterminatedAttributeValue","UnterminatedElement","ElementNeverBegun","ch","isWhitespace","_resolveEntities","_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","searchNode","component","stack","res","siblingPos","parent","newPos","currentPos","dump","encodeToXmlString","attribute","hasAttributes","parseFromString","isWhitespaceString","lastElement","isVisible","setVisibility","getOrder","getGroups","getGroup","_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","jj","coordsBuffer","colorsBuffer","tryInitGL","parameters","fieldType","isRenderable","ignoreBorder","createQuadrilaterals","_createContainer","container","horizontalRadius","verticalRadius","radius","_createQuadrilaterals","quadrilaterals","savedRect","quadPoint","_createPopup","trigger","popupElement","title","modificationDate","contents","hideWrapper","popup","_renderQuadrilaterals","quadrilateral","addLinkAttributes","target","linkService","rel","linkElement","_bindLink","destination","_bindNamedAction","_bindJSAction","jsName","detail","JSON","_getKeyModifier","_setEventListener","baseName","valueGetter","shift","modifier","_setEventListeners","eventName","storage","elementData","userValue","formattedValue","beforeInputSelectionRange","beforeInputValue","blurListener","actions","valueAsString","focus","preventScroll","userName","hidden","editable","selRange","selStart","selEnd","ColorConverters","commitKey","willCommit","_blurListener","change","fieldWidth","combWidth","_setTextStyle","TEXT_ALIGNMENT","style","fontColor","checkbox","radio","fieldValue","radioId","selectElement","optionElement","option","options","getValue","changeEx","keyDown","IGNORE_TYPES","selector","parentElements","popupLeft","popupTop","BACKGROUND_ENLIGHT","g","dateObject","PDFDateString","_formatContents","lines","line","_toggle","_show","pin","_hide","unpin","borderWidth","square","circle","coordinate","polyline","getFilenameFromUrl","stringToPDFString","_download","sortedAnnotations","popupAnnotations","downloadManager","imageResourcesPath","svgFactory","enableScripting","mouseState","isDown","rendered","elements","G","makeColorComp","R","B","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","fontFamily","_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","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","http","https","fileUriRegex","parsedUrl","parseUrl","_error","_setReadableStream","auth","host","method","handleResponse","getResponseHeader","isHttp","suggestedLength","extractFilenameFromHeader","createRequestOptions","stat","returnValues","allowRangeRequests","contentEncoding","contentDisposition","getFilenameFromContentDispositionHeader","status","needsEncodingFixup","toParamRegExp","rfc2616unquote","rfc5987decode","rfc2047decode","fixupEncoding","rfc2231getparam","decoder","fatal","textdecode","iter","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","getRequestXhr","isPendingRequest","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 ","/* 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-disable sort-exports/sort-exports */\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\nimport {\n  assert,\n  BaseException,\n  CMapCompressionType,\n  isString,\n  removeNullCharacters,\n  stringToBytes,\n  unreachable,\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 BaseCanvasFactory {\n  constructor() {\n    if (this.constructor === BaseCanvasFactory) {\n      unreachable(\"Cannot initialize BaseCanvasFactory.\");\n    }\n  }\n\n  create(width, height) {\n    unreachable(\"Abstract method `create` called.\");\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 DOMCanvasFactory extends BaseCanvasFactory {\n  constructor({ ownerDocument = globalThis.document } = {}) {\n    super();\n    this._document = ownerDocument;\n  }\n\n  create(width, height) {\n    if (width <= 0 || height <= 0) {\n      throw new Error(\"Invalid canvas size\");\n    }\n    const canvas = this._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\nclass BaseCMapReaderFactory {\n  constructor({ baseUrl = null, isCompressed = false }) {\n    if (this.constructor === BaseCMapReaderFactory) {\n      unreachable(\"Cannot initialize BaseCMapReaderFactory.\");\n    }\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    return this._fetchData(url, compressionType).catch(reason => {\n      throw new Error(\n        `Unable to load ${this.isCompressed ? \"binary \" : \"\"}CMap at: ${url}`\n      );\n    });\n  }\n\n  /**\n   * @private\n   */\n  _fetchData(url, compressionType) {\n    unreachable(\"Abstract method `_fetchData` called.\");\n  }\n}\n\nclass DOMCMapReaderFactory extends BaseCMapReaderFactory {\n  _fetchData(url, compressionType) {\n    if (\n      (typeof PDFJSDev !== \"undefined\" && PDFJSDev.test(\"MOZCENTRAL\")) ||\n      (isFetchSupported() && isValidFetchUrl(url, document.baseURI))\n    ) {\n      return fetch(url).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    }\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    });\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<number>} viewBox - The xMin, yMin, xMax and\n *   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/**\n * Gets the file name from a given URL.\n * @param {string} url\n */\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\n/**\n * @param {string} src\n * @param {boolean} [removeScriptElement]\n * @returns {Promise<void>}\n */\nfunction loadScript(src, removeScriptElement = false) {\n  return new Promise((resolve, reject) => {\n    const script = document.createElement(\"script\");\n    script.src = src;\n\n    script.onload = function (evt) {\n      if (removeScriptElement) {\n        script.remove();\n      }\n      resolve(evt);\n    };\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  addLinkAttributes,\n  BaseCanvasFactory,\n  BaseCMapReaderFactory,\n  DEFAULT_LINK_REL,\n  deprecated,\n  DOMCanvasFactory,\n  DOMCMapReaderFactory,\n  DOMSVGFactory,\n  getFilenameFromUrl,\n  isFetchSupported,\n  isValidFetchUrl,\n  LinkTarget,\n  loadScript,\n  PageViewport,\n  PDFDateString,\n  RenderingCancelledException,\n  StatTimer,\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 \"./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 AnnotationActionEventType = {\n  E: \"Mouse Enter\",\n  X: \"Mouse Exit\",\n  D: \"Mouse Down\",\n  U: \"Mouse Up\",\n  Fo: \"Focus\",\n  Bl: \"Blur\",\n  PO: \"PageOpen\",\n  PC: \"PageClose\",\n  PV: \"PageVisible\",\n  PI: \"PageInvisible\",\n  K: \"Keystroke\",\n  F: \"Format\",\n  V: \"Validate\",\n  C: \"Calculate\",\n};\n\nconst DocumentActionEventType = {\n  WC: \"WillClose\",\n  WS: \"WillSave\",\n  DS: \"DidSave\",\n  WP: \"WillPrint\",\n  DP: \"DidPrint\",\n};\n\nconst PageActionEventType = {\n  O: \"PageOpen\",\n  C: \"PageClose\",\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  errorMarkedContent: \"errorMarkedContent\",\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 allowed 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\n/**\n * @type {any}\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\n/**\n * @param {string} str\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<any>|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<Array<any>|Uint8Array|string>} arr - the array of the arrays\n *   (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\nfunction objectSize(obj) {\n  return Object.keys(obj).length;\n}\n\n// Ensures that the returned Object has a `null` prototype.\nfunction objectFromEntries(iterable) {\n  return Object.assign(Object.create(null), Object.fromEntries(iterable));\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 hexNumbers = [...Array(256).keys()].map(n =>\n  n.toString(16).padStart(2, \"0\")\n);\n\nclass Util {\n  static makeHexColor(r, g, b) {\n    return `#${hexNumbers[r]}${hexNumbers[g]}${hexNumbers[b]}`;\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 escapeString(str) {\n  // replace \"(\", \")\", \"\\n\", \"\\r\" and \"\\\"\n  // by \"\\(\", \"\\)\", \"\\\\n\", \"\\\\r\" and \"\\\\\"\n  // in order to write it in a PDF file.\n  return str.replace(/([()\\\\\\n\\r])/g, match => {\n    if (match === \"\\n\") {\n      return \"\\\\n\";\n    } else if (match === \"\\r\") {\n      return \"\\\\r\";\n    }\n    return `\\\\${match}`;\n  });\n}\n\nfunction isAscii(str) {\n  return /^[\\x00-\\x7F]*$/.test(str);\n}\n\nfunction stringToUTF16BEString(str) {\n  const buf = [\"\\xFE\\xFF\"];\n  for (let i = 0, ii = str.length; i < ii; i++) {\n    const char = str.charCodeAt(i);\n    buf.push(String.fromCharCode((char >> 8) & 0xff));\n    buf.push(String.fromCharCode(char & 0xff));\n  }\n  return buf.join(\"\");\n}\n\nfunction stringToUTF8String(str) {\n  return decodeURIComponent(escape(str));\n}\n\nfunction utf8StringToString(str) {\n  return unescape(encodeURIComponent(str));\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\nfunction getModificationDate(date = new Date()) {\n  const buffer = [\n    date.getUTCFullYear().toString(),\n    (date.getUTCMonth() + 1).toString().padStart(2, \"0\"),\n    date.getUTCDate().toString().padStart(2, \"0\"),\n    date.getUTCHours().toString().padStart(2, \"0\"),\n    date.getUTCMinutes().toString().padStart(2, \"0\"),\n    date.getUTCSeconds().toString().padStart(2, \"0\"),\n  ];\n\n  return buffer.join(\"\");\n}\n\n/**\n * Promise Capability object.\n *\n * @typedef {Object} PromiseCapability\n * @property {Promise<any>} 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\nconst XMLEntities = {\n  /* < */ 0x3c: \"&lt;\",\n  /* > */ 0x3e: \"&gt;\",\n  /* & */ 0x26: \"&amp;\",\n  /* \" */ 0x22: \"&quot;\",\n  /* ' */ 0x27: \"&apos;\",\n};\n\nfunction encodeToXmlString(str) {\n  const buffer = [];\n  let start = 0;\n  for (let i = 0, ii = str.length; i < ii; i++) {\n    const char = str.codePointAt(i);\n    if (0x20 <= char && char <= 0x7e) {\n      // ascii\n      const entity = XMLEntities[char];\n      if (entity) {\n        if (start < i) {\n          buffer.push(str.substring(start, i));\n        }\n        buffer.push(entity);\n        start = i + 1;\n      }\n    } else {\n      if (start < i) {\n        buffer.push(str.substring(start, i));\n      }\n      buffer.push(`&#x${char.toString(16).toUpperCase()};`);\n      if (char > 0xd7ff && (char < 0xe000 || char > 0xfffd)) {\n        // char is represented by two u16\n        i++;\n      }\n      start = i + 1;\n    }\n  }\n\n  if (buffer.length === 0) {\n    return str;\n  }\n\n  if (start < str.length) {\n    buffer.push(str.substring(start, str.length));\n  }\n\n  return buffer.join(\"\");\n}\n\nexport {\n  AbortException,\n  AnnotationActionEventType,\n  AnnotationBorderStyleType,\n  AnnotationFieldFlag,\n  AnnotationFlag,\n  AnnotationMarkedState,\n  AnnotationReplyType,\n  AnnotationReviewState,\n  AnnotationStateModelType,\n  AnnotationType,\n  arrayByteLength,\n  arraysToBytes,\n  assert,\n  BaseException,\n  bytesToString,\n  CMapCompressionType,\n  createObjectURL,\n  createPromiseCapability,\n  createValidAbsoluteUrl,\n  DocumentActionEventType,\n  encodeToXmlString,\n  escapeString,\n  FONT_IDENTITY_MATRIX,\n  FontType,\n  FormatError,\n  getModificationDate,\n  getVerbosityLevel,\n  IDENTITY_MATRIX,\n  ImageKind,\n  info,\n  InvalidPDFException,\n  isArrayBuffer,\n  isArrayEqual,\n  isAscii,\n  isBool,\n  IsEvalSupportedCached,\n  IsLittleEndianCached,\n  isNum,\n  isSameOrigin,\n  isString,\n  MissingPDFException,\n  objectFromEntries,\n  objectSize,\n  OPS,\n  PageActionEventType,\n  PasswordException,\n  PasswordResponses,\n  PermissionFlag,\n  removeNullCharacters,\n  setVerbosityLevel,\n  shadow,\n  StreamType,\n  string32,\n  stringToBytes,\n  stringToPDFString,\n  stringToUTF16BEString,\n  stringToUTF8String,\n  TextRenderingMode,\n  UnexpectedResponseException,\n  UnknownErrorException,\n  unreachable,\n  UNSUPPORTED_FEATURES,\n  utf8StringToString,\n  Util,\n  VerbosityLevel,\n  warn,\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\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: Firefox<65, Chrome<71, Safari<12.1\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  // 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 Object.fromEntries in legacy browsers.\n  // Support: Firefox<63, Chrome<73, Safari<12.1\n  (function checkObjectFromEntries() {\n    if (Object.fromEntries) {\n      return;\n    }\n    require(\"core-js/es/object/from-entries.js\");\n  })();\n\n  // Provides support for *recent* additions to the Promise specification,\n  // however basic Promise support is assumed to be available natively.\n  // Support: Firefox<71, Chrome<76, Safari<13\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.allSettled) {\n      return;\n    }\n    globalThis.Promise = require(\"core-js/es/promise/index.js\");\n  })();\n\n  // Support: Safari\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: Safari<10.1, 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  // Provides support for String.prototype.padStart in legacy browsers.\n  // Support: Chrome<57, Safari<10\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: Chrome<57, Safari<10\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: Chrome<54, Safari<10.1\n  (function checkObjectValues() {\n    if (Object.values) {\n      return;\n    }\n    Object.values = require(\"core-js/es/object/values.js\");\n  })();\n\n  // Provides support for Object.entries in legacy browsers.\n  // Support: Chrome<54, Safari<10.1\n  (function checkObjectEntries() {\n    if (Object.entries) {\n      return;\n    }\n    Object.entries = require(\"core-js/es/object/entries.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://www.electronjs.org/docs/api/process#processversionselectron-readonly\n// https://www.electronjs.org/docs/api/process#processtype-readonly\nconst isNodeJS =\n  typeof process === \"object\" &&\n  process + \"\" === \"[object process]\" &&\n  !process.versions.nw &&\n  !(process.versions.electron && process.type && process.type !== \"browser\");\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\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 { NodeCanvasFactory, NodeCMapReaderFactory } from \"./node_utils.js\";\nimport { AnnotationStorage } from \"./annotation_storage.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 { OptionalContentConfig } from \"./optional_content_config.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\nconst DefaultCanvasFactory =\n  (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) && isNodeJS\n    ? NodeCanvasFactory\n    : DOMCanvasFactory;\nconst DefaultCMapReaderFactory =\n  (typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) && isNodeJS\n    ? NodeCMapReaderFactory\n    : DOMCMapReaderFactory;\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 *\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 * @typedef { Int8Array | Uint8Array | Uint8ClampedArray |\n *            Int16Array | Uint16Array |\n *            Int32Array | Uint32Array | Float32Array |\n *            Float64Array\n * } TypedArray\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<number>|string} [data] - Binary PDF data. Use\n *    typed 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 progress\n *   reports and range requests operations.\n * @property {PDFDataRangeTransport} [range] - Allows for using a custom range\n *   transport implementation.\n * @property {number} [rangeChunkSize] - Specify maximum number of bytes fetched\n *   per range request. The default value is {@link DEFAULT_RANGE_CHUNK_SIZE}.\n * @property {PDFWorker} [worker] - The worker that will be used for loading and\n *   parsing the PDF data.\n * @property {number} [verbosity] - Controls the logging level; the constants\n *   from {@link VerbosityLevel} should be used.\n * @property {string} [docBaseUrl] - The base URL of the document, used when\n *   attempting to recover valid absolute URLs for annotations, and outline\n *   items, that (incorrectly) only specify relative URLs.\n * @property {string} [cMapUrl] - The URL where the predefined Adobe CMaps are\n *   located. Include the trailing slash.\n * @property {boolean} [cMapPacked] - Specifies if the Adobe CMaps are binary\n *   packed or not.\n * @property {Object} [CMapReaderFactory] - The factory that will be used when\n *   reading built-in CMap files. Providing a custom factory is useful for\n *   environments without Fetch API or `XMLHttpRequest` support, such as\n *   Node.js. 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 in total\n *   pixels, i.e. width * height. Images above this value will not be rendered.\n *   Use -1 for no limit, which is also the default value.\n * @property {boolean} [isEvalSupported] - Determines if we can evaluate strings\n *   as JavaScript. Primarily used to improve performance of font rendering, and\n *   when parsing PDF functions. The default value is `true`.\n * @property {boolean} [disableFontFace] - By default fonts are converted to\n *   OpenType fonts and loaded via `@font-face` rules. If disabled, fonts will\n *   be rendered using a built-in font renderer that constructs the glyphs with\n *   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 {HTMLDocument} [ownerDocument] - Specify an explicit document\n *   context to create elements with and to load resources, such as fonts,\n *   into. Defaults to the current document.\n * @property {boolean} [disableRange] - Disable range request loading of PDF\n *   files. When enabled, and if the server supports partial content requests,\n *   then the PDF will be fetched in chunks. The default value is `false`.\n * @property {boolean} [disableStream] - Disable streaming of PDF file data.\n *   By default PDF.js attempts to load PDF files in chunks. The default value\n *   is `false`.\n * @property {boolean} [disableAutoFetch] - Disable pre-fetching of PDF file\n *   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 *\n *   NOTE: It is also necessary to disable streaming, see above, in order for\n *   disabling of pre-fetching to work correctly.\n * @property {boolean} [pdfBug] - Enables special hooks for debugging PDF.js\n *   (see `web/debugger.js`). The default value is `false`.\n */\n\n/**\n * @typedef {Object} PDFDocumentStats\n * @property {Object<string, boolean>} streamTypes - Used stream types in the\n *   document (an item is set to true if specific stream ID was used in the\n *   document).\n * @property {Object<string, boolean>} fontTypes - Used font types in the\n *   document (an item is set to true if specific font ID was used in the\n *   document).\n */\n\n/**\n * This is the main entry point for loading a PDF and interacting with it.\n *\n * NOTE: If a URL is used to fetch the PDF data a standard Fetch API call (or\n * XHR as fallback) is used, which means it must follow same origin rules,\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 file 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 =\n    params.CMapReaderFactory || DefaultCMapReaderFactory;\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  if (typeof params.ownerDocument === \"undefined\") {\n    params.ownerDocument = globalThis.document;\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 *\n * @param {PDFWorker} worker\n * @param {Object} source\n * @param {PDFDataRangeTransport} pdfDataRangeTransport\n * @param {string} docId - Unique document ID, used in `MessageHandler`.\n * @returns {Promise} A promise that is resolved when the worker ID of the\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\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 * @typedef {Object} PDFDocumentLoadingTask\n * @property {string} docId - Unique identifier for the document loading task.\n * @property {boolean} destroyed - Whether the loading task is destroyed or not.\n * @property {function} [onPassword] - Callback to request a password if a wrong\n *   or no password was provided. The callback receives two parameters: a\n *   function that should be called with the new password, and a reason (see\n *   {@link PasswordResponses}).\n * @property {function} [onProgress] - Callback to be able to monitor the\n *   loading progress of the PDF file (necessary to implement e.g. a loading\n *   bar). The callback receives an {Object} with the properties `loaded`\n *   ({number}) and `total` ({number}) that indicate how many bytes are loaded.\n * @property {function} [onUnsupportedFeature] - Callback for when an\n *   unsupported feature is used in the PDF document. The callback receives an\n *   {@link UNSUPPORTED_FEATURES} argument.\n * @property {Promise<PDFDocumentProxy>} promise - Promise for document loading\n *   task completion.\n * @property {function} destroy - Abort all network requests and destroy\n *   the worker. Returns a promise that is resolved when destruction is\n *   completed.\n */\n\n/**\n * @type {any}\n * @ignore\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 identifier for the document loading task.\n       * @type {string}\n       */\n      this.docId = \"d\" + nextDocumentId++;\n\n      /**\n       * Whether the loading task is destroyed or not.\n       * @type {boolean}\n       */\n      this.destroyed = false;\n\n      /**\n       * Callback to request a password if a wrong or no password was provided.\n       * The callback receives two parameters: a function that should be called\n       * with the new password, and a reason (see {@link PasswordResponses}).\n       * @type {function}\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 `loaded` ({number}) and `total`\n       * ({number}) that indicate how many bytes are loaded.\n       * @type {function}\n       */\n      this.onProgress = null;\n\n      /**\n       * Callback for when an unsupported feature is used in the PDF document.\n       * The callback receives an {@link UNSUPPORTED_FEATURES} argument.\n       * @type {function}\n       */\n      this.onUnsupportedFeature = null;\n    }\n\n    /**\n     * Promise for document loading task completion.\n     * @type {Promise<PDFDocumentProxy>}\n     */\n    get promise() {\n      return this._capability.promise;\n    }\n\n    /**\n     * @returns {Promise<void>} A promise that is resolved when destruction is\n     *   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 */\nclass PDFDataRangeTransport {\n  /**\n   * @param {number} length\n   * @param {Uint8Array} initialData\n   * @param {boolean} [progressiveDone]\n   */\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.\n */\nclass PDFDocumentProxy {\n  constructor(pdfInfo, transport) {\n    this._pdfInfo = pdfInfo;\n    this._transport = transport;\n  }\n\n  /**\n   * @type {AnnotationStorage} Storage for annotation data in forms.\n   */\n  get annotationStorage() {\n    return shadow(this, \"annotationStorage\", new AnnotationStorage());\n  }\n\n  /**\n   * @type {number} Total number of pages in the PDF file.\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<PDFPageProxy>} A promise that is resolved with\n   *   a {@link PDFPageProxy} 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<{num: number, gen: number}>} A promise that is resolved\n   *   with the page index (starting from zero) that is associated with the\n   *   reference.\n   */\n  getPageIndex(ref) {\n    return this._transport.getPageIndex(ref);\n  }\n\n  /**\n   * @returns {Promise<Object<string, Array<any>>>} A promise that is resolved\n   *   with a mapping from named destinations to references.\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<Array<any>>} A promise that is resolved with all\n   *   information of the given named destination.\n   */\n  getDestination(id) {\n    return this._transport.getDestination(id);\n  }\n\n  /**\n   * @returns {Promise<Array<string> | null>} A promise that is resolved with\n   *   an {Array} containing the page labels that correspond to the page\n   *   indexes, or `null` when no page labels are present in the PDF file.\n   */\n  getPageLabels() {\n    return this._transport.getPageLabels();\n  }\n\n  /**\n   * @returns {Promise<string>} A promise that is resolved with a {string}\n   *   containing the page layout name.\n   */\n  getPageLayout() {\n    return this._transport.getPageLayout();\n  }\n\n  /**\n   * @returns {Promise<string>} A promise that is resolved with a {string}\n   *   containing the page mode name.\n   */\n  getPageMode() {\n    return this._transport.getPageMode();\n  }\n\n  /**\n   * @returns {Promise<Object | null>} A promise that is resolved with an\n   *   {Object} containing the viewer preferences, or `null` when no viewer\n   *   preferences are present in the PDF file.\n   */\n  getViewerPreferences() {\n    return this._transport.getViewerPreferences();\n  }\n\n  /**\n   * @returns {Promise<any | null>} A promise that is resolved with an {Array}\n   *   containing the destination, or `null` when no open action is present\n   *   in the PDF.\n   */\n  getOpenAction() {\n    return this._transport.getOpenAction();\n  }\n\n  /**\n   * @returns {Promise<any>} A promise that is resolved with a lookup table\n   *   for mapping named attachments to their content.\n   */\n  getAttachments() {\n    return this._transport.getAttachments();\n  }\n\n  /**\n   * @returns {Promise<Array<string> | null>} A promise that is resolved with\n   *   an {Array} of all the JavaScript strings in the name tree, or `null`\n   *   if no JavaScript exists.\n   */\n  getJavaScript() {\n    return this._transport.getJavaScript();\n  }\n\n  /**\n   * @returns {Promise<Object | null>} A promise that is resolved with\n   *   an {Object} with the JavaScript actions:\n   *     - from the name tree (like getJavaScript);\n   *     - from A or AA entries in the catalog dictionary.\n   *   , or `null` if no JavaScript exists.\n   */\n  getJSActions() {\n    return this._transport.getDocJSActions();\n  }\n\n  /**\n   * @typedef {Object} OutlineNode\n   * @property {string} title\n   * @property {boolean} bold\n   * @property {boolean} italic\n   * @property {Uint8ClampedArray} color - The color in RGB format to use for\n   *   display purposes.\n   * @property {string | Array<any> | null} dest\n   * @property {string | null} url\n   * @property {string | undefined} unsafeUrl\n   * @property {boolean | undefined} newWindow\n   * @property {number | undefined} count\n   * @property {Array<OutlineNode>} items\n   */\n\n  /**\n   * @returns {Promise<Array<OutlineNode>>} A promise that is resolved with an\n   *   {Array} that is a tree outline (if it has one) of the PDF file.\n   */\n  getOutline() {\n    return this._transport.getOutline();\n  }\n\n  /**\n   * @returns {Promise<OptionalContentConfig>} A promise that is resolved with\n   *   an {@link OptionalContentConfig} that contains all the optional content\n   *   groups (assuming that the document has any).\n   */\n  getOptionalContentConfig() {\n    return this._transport.getOptionalContentConfig();\n  }\n\n  /**\n   * @returns {Promise<Array<number> | null>} A promise that is resolved with\n   *   an {Array} that contains the permission flags for the PDF document, or\n   *   `null` when no permissions are present in the PDF file.\n   */\n  getPermissions() {\n    return this._transport.getPermissions();\n  }\n\n  /**\n   * @returns {Promise<{ info: Object, metadata: Metadata }>} A promise that is\n   *   resolved with an {Object} that has `info` and `metadata` properties.\n   *   `info` is an {Object} filled with anything available in the information\n   *   dictionary and similarly `metadata` is a {Metadata} object with\n   *   information from the metadata section of the PDF.\n   */\n  getMetadata() {\n    return this._transport.getMetadata();\n  }\n\n  /**\n   * @typedef {Object} MarkInfo\n   * Properties correspond to Table 321 of the PDF 32000-1:2008 spec.\n   * @property {boolean} Marked\n   * @property {boolean} UserProperties\n   * @property {boolean} Suspects\n   */\n\n  /**\n   * @returns {Promise<MarkInfo | null>} A promise that is resolved with\n   *   a {MarkInfo} object that contains the MarkInfo flags for the PDF\n   *   document, or `null` when no MarkInfo values are present in the PDF file.\n   */\n  getMarkInfo() {\n    return this._transport.getMarkInfo();\n  }\n\n  /**\n   * @returns {Promise<TypedArray>} A promise that is resolved with a\n   *   {TypedArray} that has the raw data from the PDF.\n   */\n  getData() {\n    return this._transport.getData();\n  }\n\n  /**\n   * @returns {Promise<{ length: number }>} A promise that is resolved when the\n   *   document's data is loaded. It is resolved with an {Object} that contains\n   *   the `length` 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<PDFDocumentStats>} A promise this is resolved with\n   *   current statistics about document structures (see\n   *   {@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 worker\n   * 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 {DocumentInitParameters} A subset of the current\n   *   {DocumentInitParameters}, which are either needed in the viewer and/or\n   *   whose default values may be affected 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   * @param {AnnotationStorage} annotationStorage - Storage for annotation\n   *   data in forms.\n   * @returns {Promise<Uint8Array>} A promise that is resolved with a\n   *   {Uint8Array} containing the full data of the saved document.\n   */\n  saveDocument(annotationStorage) {\n    return this._transport.saveDocument(annotationStorage);\n  }\n\n  /**\n   * @returns {Promise<Array<Object> | null>} A promise that is resolved with an\n   *   {Array<Object>} containing /AcroForm field data for the JS sandbox,\n   *   or `null` when no field data is present in the PDF file.\n   */\n  getFieldObjects() {\n    return this._transport.getFieldObjects();\n  }\n\n  /**\n   * @returns {Promise<boolean>} A promise that is resolved with `true`\n   *   if some /AcroForm fields have JavaScript actions.\n   */\n  hasJSActions() {\n    return this._transport.hasJSActions();\n  }\n\n  /**\n   * @returns {Promise<Array<string> | null>} A promise that is resolved with an\n   *   {Array<string>} containing IDs of annotations that have a calculation\n   *   action, or `null` when no such annotations are present in the PDF file.\n   */\n  getCalculationOrderIds() {\n    return this._transport.getCalculationOrderIds();\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<TextItem>} items - Array of {@link TextItem} objects.\n * @property {Object<string, TextStyle>} styles - {@link TextStyle} objects,\n *   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<any>} 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 - Whether or not the text is in vertical mode.\n * @property {string} fontFamily - The 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' (printable\n *   annotations). 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 calling\n *   the `PDFPageProxy.getViewport` method.\n * @property {string} [intent] - Rendering intent, can be 'display' or 'print'.\n *   The default value is 'display'.\n * @property {boolean} [enableWebGL] - Enables WebGL accelerated rendering for\n *   some operations. The default value is `false`.\n * @property {boolean} [renderInteractiveForms] - Whether or not interactive\n *   form elements are rendered in the display layer. If so, we do not render\n *   them on the canvas as well.\n * @property {Array<any>} [transform] - Additional transform, applied just\n *   before viewport transform.\n * @property {Object} [imageLayer] - An object that has `beginLayout`,\n *   `endLayout` and `appendImage` functions.\n * @property {Object} [canvasFactory] - The factory instance that will be used\n *   when creating canvases. The default value is {new DOMCanvasFactory()}.\n * @property {Object | string} [background] - Background to use for the canvas.\n *   Any valid `canvas.fillStyle` can be used: a `DOMString` parsed as CSS\n *   <color> value, a `CanvasGradient` object (a linear or radial gradient) or\n *   a `CanvasPattern` object (a repetitive image). The default value is\n *   'rgb(255,255,255)'.\n * @property {AnnotationStorage} [annotationStorage] - Storage for annotation\n *   data in forms.\n * @property {Promise<OptionalContentConfig>} [optionalContentConfigPromise] -\n *   A promise that should resolve with an {@link OptionalContentConfig}\n *   created from `PDFDocumentProxy.getOptionalContentConfig`. If `null`,\n *   the configuration will be fetched automatically with the default visibility\n *   states set.\n */\n\n/**\n * PDF page operator list.\n *\n * @typedef {Object} PDFOperatorList\n * @property {Array<number>} fnArray - Array containing the operator functions.\n * @property {Array<any>} argsArray - Array containing the arguments of the\n *   functions.\n */\n\n/**\n * Proxy to a `PDFPage` in the worker thread.\n */\nclass PDFPageProxy {\n  constructor(pageIndex, pageInfo, transport, ownerDocument, pdfBug = false) {\n    this._pageIndex = pageIndex;\n    this._pageInfo = pageInfo;\n    this._ownerDocument = ownerDocument;\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 = new Map();\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<number>} An array of the visible portion of the PDF page in\n   *   user 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<Array<any>>} A promise that is resolved with an\n   *   {Array} of the 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   * @returns {Promise<Object>} A promise that is resolved with an\n   *   {Object} with JS actions.\n   */\n  getJSActions() {\n    return (this._jsActionsPromise ||= this._transport.getPageJSActions(\n      this._pageIndex\n    ));\n  }\n\n  /**\n   * Begins the process of rendering a page to the desired context.\n   *\n   * @param {RenderParameters} params Page render parameters.\n   * @returns {RenderTask} An object that contains a promise that is\n   *   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    annotationStorage = null,\n    optionalContentConfigPromise = 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 (!optionalContentConfigPromise) {\n      optionalContentConfigPromise = this._transport.getOptionalContentConfig();\n    }\n\n    let intentState = this._intentStates.get(renderingIntent);\n    if (!intentState) {\n      intentState = Object.create(null);\n      this._intentStates.set(renderingIntent, intentState);\n    }\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 =\n      canvasFactory ||\n      new DefaultCanvasFactory({ ownerDocument: this._ownerDocument });\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        annotationStorage: annotationStorage?.getAll() || null,\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    Promise.all([\n      intentState.displayReadyCapability.promise,\n      optionalContentConfigPromise,\n    ])\n      .then(([transparency, optionalContentConfig]) => {\n        if (this.pendingCleanup) {\n          complete();\n          return;\n        }\n        if (this._stats) {\n          this._stats.time(\"Rendering\");\n        }\n        internalRenderTask.initializeGraphics({\n          transparency,\n          optionalContentConfig,\n        });\n        internalRenderTask.operatorListChanged();\n      })\n      .catch(complete);\n\n    return renderTask;\n  }\n\n  /**\n   * @returns {Promise<PDFOperatorList>} A promise resolved with an\n   *   {@link PDFOperatorList} 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    let intentState = this._intentStates.get(renderingIntent);\n    if (!intentState) {\n      intentState = Object.create(null);\n      this._intentStates.set(renderingIntent, intentState);\n    }\n    let opListTask;\n\n    if (!intentState.opListReadCapability) {\n      opListTask = Object.create(null);\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} Stream for reading text content 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<TextContent>} A promise that is resolved with a\n   *   {@link TextContent} object that represents the page's 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    for (const [intent, intentState] of this._intentStates) {\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        continue;\n      }\n      for (const internalRenderTask of intentState.renderTasks) {\n        waitOn.push(internalRenderTask.completed);\n        internalRenderTask.cancel();\n      }\n    }\n    this.objs.clear();\n    this.annotationsPromise = null;\n    this._jsActionsPromise = null;\n    this.pendingCleanup = false;\n    return Promise.all(waitOn);\n  }\n\n  /**\n   * Cleans up resources allocated by the page.\n   *\n   * @param {boolean} [resetStats] - Reset page stats, if enabled.\n   *   The default value is `false`.\n   * @returns {boolean} Indicates 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 (!this.pendingCleanup) {\n      return false;\n    }\n    for (const { renderTasks, operatorList } of this._intentStates.values()) {\n      if (renderTasks.length !== 0 || !operatorList.lastChunk) {\n        return false;\n      }\n    }\n\n    this._intentStates.clear();\n    this.objs.clear();\n    this.annotationsPromise = null;\n    this._jsActionsPromise = 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.get(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.get(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(new AbortException(reason?.message));\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    for (const [intent, curIntentState] of this._intentStates) {\n      if (curIntentState === intentState) {\n        this._intentStates.delete(intent);\n        break;\n      }\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        if (transfers?.includes(buffer)) {\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` object.\n * @property {number} [verbosity] - Controls the logging level; the\n *   constants from {@link VerbosityLevel} should be used.\n */\n\n/** @type {any} */\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 = 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 = 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        const worker = await 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 that 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      ownerDocument: params.ownerDocument,\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  get loadingTaskSettled() {\n    return this.loadingTask._capability.settled;\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    // Allow `AnnotationStorage`-related clean-up when destroying the document.\n    if (this.loadingTaskSettled) {\n      const annotationStorageResetModified = this.loadingTask.promise\n        .then(pdfDocument => {\n          // Avoid initializing the `annotationStorage` if it doesn't exist.\n          if (pdfDocument.hasOwnProperty(\"annotationStorage\")) {\n            pdfDocument.annotationStorage.resetModified();\n          }\n        })\n        .catch(() => {});\n      waitOn.push(annotationStorageResetModified);\n    }\n    Promise.all(waitOn).then(() => {\n      this.commonObjs.clear();\n      this.fontLoader.clear();\n      this._hasJSActionsPromise = null;\n\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        sink.ready.catch(readyReason => {\n          if (this.destroyed) {\n            return; // Ignore any pending requests if the worker was terminated.\n          }\n          throw readyReason;\n        });\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        sink.ready.catch(readyReason => {\n          if (this.destroyed) {\n            return; // Ignore any pending requests if the worker was terminated.\n          }\n          throw readyReason;\n        });\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 (!(reason instanceof Error)) {\n        const msg = \"DocException - expected a valid Error.\";\n        if (\n          typeof PDFJSDev === \"undefined\" ||\n          PDFJSDev.test(\"!PRODUCTION || TESTING\")\n        ) {\n          unreachable(msg);\n        } else {\n          warn(msg);\n        }\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 (params.pdfBug && globalThis.FontInspector?.enabled) {\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 \"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 (imageData?.data?.length > MAX_IMAGE_SIZE_TO_STORE) {\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.ownerDocument,\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  saveDocument(annotationStorage) {\n    return this.messageHandler\n      .sendWithPromise(\"SaveDocument\", {\n        numPages: this._numPages,\n        annotationStorage: annotationStorage?.getAll() || null,\n        filename: this._fullReader?.filename ?? null,\n      })\n      .finally(() => {\n        if (annotationStorage) {\n          annotationStorage.resetModified();\n        }\n      });\n  }\n\n  getFieldObjects() {\n    return this.messageHandler.sendWithPromise(\"GetFieldObjects\", null);\n  }\n\n  hasJSActions() {\n    return (this._hasJSActionsPromise ||= this.messageHandler.sendWithPromise(\n      \"HasJSActions\",\n      null\n    ));\n  }\n\n  getCalculationOrderIds() {\n    return this.messageHandler.sendWithPromise(\"GetCalculationOrderIds\", null);\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  getDocJSActions() {\n    return this.messageHandler.sendWithPromise(\"GetDocJSActions\", null);\n  }\n\n  getPageJSActions(pageIndex) {\n    return this.messageHandler.sendWithPromise(\"GetPageJSActions\", {\n      pageIndex,\n    });\n  }\n\n  getOutline() {\n    return this.messageHandler.sendWithPromise(\"GetOutline\", null);\n  }\n\n  getOptionalContentConfig() {\n    return this.messageHandler\n      .sendWithPromise(\"GetOptionalContentConfig\", null)\n      .then(results => {\n        return new OptionalContentConfig(results);\n      });\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?.filename ?? null,\n          contentLength: this._fullReader?.contentLength ?? null,\n        };\n      });\n  }\n\n  getMarkInfo() {\n    return this.messageHandler.sendWithPromise(\"GetMarkInfo\", null);\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      this._hasJSActionsPromise = null;\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?.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 */\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<void>}\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    get completed() {\n      return this.capability.promise.catch(function () {\n        // Ignoring errors, since we only want to know when rendering is\n        // no longer pending.\n      });\n    }\n\n    initializeGraphics({ transparency = false, optionalContentConfig }) {\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 (this._pdfBug && globalThis.StepperManager?.enabled) {\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        optionalContentConfig\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\n/** @type {string} */\nconst version =\n  typeof PDFJSDev !== \"undefined\" ? PDFJSDev.eval(\"BUNDLE_VERSION\") : null;\n/** @type {string} */\nconst build =\n  typeof PDFJSDev !== \"undefined\" ? PDFJSDev.eval(\"BUNDLE_BUILD\") : null;\n\nexport {\n  build,\n  DefaultCanvasFactory,\n  DefaultCMapReaderFactory,\n  getDocument,\n  LoopbackPort,\n  PDFDataRangeTransport,\n  PDFDocumentProxy,\n  PDFPageProxy,\n  PDFWorker,\n  setPDFNetworkStreamFactory,\n  version,\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({\n    docId,\n    onUnsupportedFeature,\n    ownerDocument = globalThis.document,\n  }) {\n    if (this.constructor === BaseFontLoader) {\n      unreachable(\"Cannot initialize BaseFontLoader.\");\n    }\n    this.docId = docId;\n    this._onUnsupportedFeature = onUnsupportedFeature;\n    this._document = ownerDocument;\n\n    this.nativeFontFaces = [];\n    this.styleElement = null;\n  }\n\n  addNativeFontFace(nativeFontFace) {\n    this.nativeFontFaces.push(nativeFontFace);\n    this._document.fonts.add(nativeFontFace);\n  }\n\n  insertRule(rule) {\n    let styleElement = this.styleElement;\n    if (!styleElement) {\n      styleElement = this.styleElement = this._document.createElement(\"style\");\n      styleElement.id = `PDFJS_FONT_STYLE_TAG_${this.docId}`;\n      this._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(nativeFontFace => {\n      this._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    return shadow(this, \"isFontLoadingAPISupported\", !!this._document?.fonts);\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(params) {\n      super(params);\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?.[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 = this._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 = this._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 = this._document.createElement(\"span\");\n        span.textContent = \"Hi\";\n        span.style.fontFamily = names[i];\n        div.appendChild(span);\n      }\n      this._document.body.appendChild(div);\n\n      isFontReady(loadTestFontId, () => {\n        this._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 2020 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 { BaseCanvasFactory, BaseCMapReaderFactory } from \"./display_utils.js\";\nimport { isNodeJS } from \"../shared/is_node.js\";\nimport { unreachable } from \"../shared/util.js\";\n\nlet NodeCanvasFactory = class {\n  constructor() {\n    unreachable(\"Not implemented: NodeCanvasFactory\");\n  }\n};\n\nlet NodeCMapReaderFactory = class {\n  constructor() {\n    unreachable(\"Not implemented: NodeCMapReaderFactory\");\n  }\n};\n\nif ((typeof PDFJSDev === \"undefined\" || PDFJSDev.test(\"GENERIC\")) && isNodeJS) {\n  NodeCanvasFactory = class extends BaseCanvasFactory {\n    create(width, height) {\n      if (width <= 0 || height <= 0) {\n        throw new Error(\"Invalid canvas size\");\n      }\n      const Canvas = __non_webpack_require__(\"canvas\");\n      const canvas = Canvas.createCanvas(width, height);\n      return {\n        canvas,\n        context: canvas.getContext(\"2d\"),\n      };\n    }\n  };\n\n  NodeCMapReaderFactory = class extends BaseCMapReaderFactory {\n    _fetchData(url, compressionType) {\n      return new Promise((resolve, reject) => {\n        const fs = __non_webpack_require__(\"fs\");\n        fs.readFile(url, (error, data) => {\n          if (error || !data) {\n            reject(new Error(error));\n            return;\n          }\n          resolve({ cMapData: new Uint8Array(data), compressionType });\n        });\n      });\n    }\n  };\n}\n\nexport { NodeCanvasFactory, NodeCMapReaderFactory };\n","/* Copyright 2020 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 { objectFromEntries } from \"../shared/util.js\";\n\n/**\n * Key/value storage for annotation data in forms.\n */\nclass AnnotationStorage {\n  constructor() {\n    this._storage = new Map();\n    this._modified = false;\n\n    // Callbacks to signal when the modification state is set or reset.\n    // This is used by the viewer to only bind on `beforeunload` if forms\n    // are actually edited to prevent doing so unconditionally since that\n    // can have undesirable efffects.\n    this.onSetModified = null;\n    this.onResetModified = null;\n  }\n\n  /**\n   * Get the value for a given key if it exists\n   * or store and return the default value\n   *\n   * @public\n   * @memberof AnnotationStorage\n   * @param {string} key\n   * @param {Object} defaultValue\n   * @returns {Object}\n   */\n  getOrCreateValue(key, defaultValue) {\n    if (this._storage.has(key)) {\n      return this._storage.get(key);\n    }\n\n    this._storage.set(key, defaultValue);\n    return defaultValue;\n  }\n\n  /**\n   * Set the value for a given key\n   *\n   * @public\n   * @memberof AnnotationStorage\n   * @param {string} key\n   * @param {Object} value\n   */\n  setValue(key, value) {\n    const obj = this._storage.get(key);\n    let modified = false;\n    if (obj !== undefined) {\n      for (const [entry, val] of Object.entries(value)) {\n        if (obj[entry] !== val) {\n          modified = true;\n          obj[entry] = val;\n        }\n      }\n    } else {\n      this._storage.set(key, value);\n      modified = true;\n    }\n    if (modified) {\n      this._setModified();\n    }\n  }\n\n  getAll() {\n    if (this._storage.size === 0) {\n      return null;\n    }\n    return objectFromEntries(this._storage);\n  }\n\n  get size() {\n    return this._storage.size;\n  }\n\n  /**\n   * @private\n   */\n  _setModified() {\n    if (!this._modified) {\n      this._modified = true;\n      if (typeof this.onSetModified === \"function\") {\n        this.onSetModified();\n      }\n    }\n  }\n\n  resetModified() {\n    if (this._modified) {\n      this._modified = false;\n      if (typeof this.onResetModified === \"function\") {\n        this.onResetModified();\n      }\n    }\n  }\n}\n\nexport { AnnotationStorage };\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// Minimal font size that would be used during canvas fillText operations.\nconst MIN_FONT_SIZE = 16;\n// Maximum font size that would be used during canvas fillText operations.\nconst MAX_FONT_SIZE = 100;\nconst MAX_GROUP_SIZE = 4096;\n\nconst COMPILE_TYPE3_GLYPHS = true;\nconst MAX_SIZE_TO_COMPILE = 1000;\n\nconst 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        const m = this._transformMatrix;\n        const 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        const ad_bc = a * d - b * c;\n        const 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      const 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      const 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      const 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      const 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      const 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      const cosValue = Math.cos(angle);\n      const sinValue = Math.sin(angle);\n\n      const 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\nconst 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      let 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 (const id in this.cache) {\n        const 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  const POINT_TO_PROCESS_LIMIT = 1000;\n\n  const width = imgData.width,\n    height = imgData.height,\n    width1 = width + 1;\n  let i, ii, j, j0;\n  const points = new Uint8Array(width1 * (height + 1));\n  // prettier-ignore\n  const 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  const lineSize = (width + 7) & ~7,\n    data0 = imgData.data;\n  const data = new Uint8Array(lineSize * height);\n  let pos = 0;\n  for (i = 0, ii = data0.length; i < ii; i++) {\n    const elem = data0[i];\n    let mask = 128;\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  let 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    let 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  const steps = new Int32Array([0, width1, -1, 0, -width1, 0, 0, 0, 1]);\n  const outlines = [];\n  for (i = 0; count && i <= height; i++) {\n    let p = i * width1;\n    const end = p + width;\n    while (p < end && !points[p]) {\n      p++;\n    }\n    if (p === end) {\n      continue;\n    }\n    const coords = [p % width1, i];\n\n    const p0 = p;\n    let type = points[p];\n    do {\n      const step = steps[type];\n      do {\n        p += step;\n      } while (!points[p]);\n\n      const 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  const 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      const 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\nconst 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    this.transferMaps = null;\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\n/**\n * @type {any}\n */\nconst 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  const EXECUTION_TIME = 15;\n  // Defines the number of steps before checking the execution time\n  const 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    optionalContentConfig\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.contentVisible = true;\n    this.markedContentStack = [];\n    this.optionalContentConfig = optionalContentConfig;\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, transferMaps = null) {\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    const height = imgData.height,\n      width = imgData.width;\n    const partialChunkHeight = height % FULL_CHUNK_HEIGHT;\n    const fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;\n    const totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;\n\n    const chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);\n    let srcPos = 0,\n      destPos;\n    const src = imgData.data;\n    const dest = chunkImgData.data;\n    let i, j, thisChunkHeight, elemsInThisChunk;\n\n    let transferMapRed, transferMapGreen, transferMapBlue, transferMapGray;\n    if (transferMaps) {\n      switch (transferMaps.length) {\n        case 1:\n          transferMapRed = transferMaps[0];\n          transferMapGreen = transferMaps[0];\n          transferMapBlue = transferMaps[0];\n          transferMapGray = transferMaps[0];\n          break;\n        case 4:\n          transferMapRed = transferMaps[0];\n          transferMapGreen = transferMaps[1];\n          transferMapBlue = transferMaps[2];\n          transferMapGray = transferMaps[3];\n          break;\n      }\n    }\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      const srcLength = src.byteLength;\n      const dest32 = new Uint32Array(dest.buffer, 0, dest.byteLength >> 2);\n      const dest32DataLength = dest32.length;\n      const fullSrcDiff = (width + 7) >> 3;\n      let white = 0xffffffff;\n      let black = IsLittleEndianCached.value ? 0xff000000 : 0x000000ff;\n\n      if (transferMapGray) {\n        if (transferMapGray[0] === 0xff && transferMapGray[0xff] === 0) {\n          [white, black] = [black, white];\n        }\n      }\n\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          const srcDiff = srcLength - srcPos;\n          let k = 0;\n          const kEnd = srcDiff > fullSrcDiff ? width : srcDiff * 8 - 7;\n          const kEndUnrolled = kEnd & ~7;\n          let mask = 0;\n          let 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      const hasTransferMaps = !!(\n        transferMapRed ||\n        transferMapGreen ||\n        transferMapBlue\n      );\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        if (hasTransferMaps) {\n          for (let k = 0; k < elemsInThisChunk; k += 4) {\n            if (transferMapRed) {\n              dest[k + 0] = transferMapRed[dest[k + 0]];\n            }\n            if (transferMapGreen) {\n              dest[k + 1] = transferMapGreen[dest[k + 1]];\n            }\n            if (transferMapBlue) {\n              dest[k + 2] = transferMapBlue[dest[k + 2]];\n            }\n          }\n        }\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\n        if (hasTransferMaps) {\n          for (let k = 0; k < elemsInThisChunk; k += 4) {\n            if (transferMapRed) {\n              dest[k + 0] = transferMapRed[dest[k + 0]];\n            }\n            if (transferMapGreen) {\n              dest[k + 1] = transferMapGreen[dest[k + 1]];\n            }\n            if (transferMapBlue) {\n              dest[k + 2] = transferMapBlue[dest[k + 2]];\n            }\n          }\n        }\n\n        ctx.putImageData(chunkImgData, 0, j);\n      }\n    } else if (imgData.kind === ImageKind.RGB_24BPP) {\n      // RGB, 24-bits per pixel.\n      const hasTransferMaps = !!(\n        transferMapRed ||\n        transferMapGreen ||\n        transferMapBlue\n      );\n\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\n        if (hasTransferMaps) {\n          for (let k = 0; k < destPos; k += 4) {\n            if (transferMapRed) {\n              dest[k + 0] = transferMapRed[dest[k + 0]];\n            }\n            if (transferMapGreen) {\n              dest[k + 1] = transferMapGreen[dest[k + 1]];\n            }\n            if (transferMapBlue) {\n              dest[k + 2] = transferMapBlue[dest[k + 2]];\n            }\n          }\n        }\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    const height = imgData.height,\n      width = imgData.width;\n    const partialChunkHeight = height % FULL_CHUNK_HEIGHT;\n    const fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;\n    const totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;\n\n    const chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);\n    let srcPos = 0;\n    const src = imgData.data;\n    const dest = chunkImgData.data;\n\n    for (let i = 0; i < totalChunks; i++) {\n      const 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      let destPos = 3; // alpha component offset\n      for (let j = 0; j < thisChunkHeight; j++) {\n        let elem,\n          mask = 0;\n        for (let k = 0; k < width; k++) {\n          if (!mask) {\n            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    const properties = [\n      \"strokeStyle\",\n      \"fillStyle\",\n      \"fillRule\",\n      \"globalAlpha\",\n      \"lineWidth\",\n      \"lineCap\",\n      \"lineJoin\",\n      \"miterLimit\",\n      \"globalCompositeOperation\",\n      \"font\",\n    ];\n    for (let i = 0, ii = properties.length; i < ii; i++) {\n      const 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    const length = bytes.length;\n    for (let i = 3; i < length; i += 4) {\n      const 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        const 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    const length = maskData.length;\n    const scale = 1 / 255;\n    for (let i = 3; i < length; i += 4) {\n      const 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    const length = maskData.length;\n    for (let i = 3; i < length; i += 4) {\n      const 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    const hasBackdrop = !!backdrop;\n    const r0 = hasBackdrop ? backdrop[0] : 0;\n    const g0 = hasBackdrop ? backdrop[1] : 0;\n    const b0 = hasBackdrop ? backdrop[2] : 0;\n\n    let composeFn;\n    if (subtype === \"Luminosity\") {\n      composeFn = composeSMaskLuminosity;\n    } else {\n      composeFn = composeSMaskAlpha;\n    }\n\n    // processing image in chunks to save memory\n    const PIXELS_TO_PROCESS = 1048576;\n    const chunkSize = Math.min(height, Math.ceil(PIXELS_TO_PROCESS / width));\n    for (let row = 0; row < height; row += chunkSize) {\n      const chunkHeight = Math.min(chunkSize, height - row);\n      const maskData = maskCtx.getImageData(0, row, width, chunkHeight);\n      const 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    const mask = smask.canvas;\n    const 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    const 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  const LINE_CAP_STYLES = [\"butt\", \"round\", \"square\"];\n  const LINE_JOIN_STYLES = [\"miter\", \"round\", \"bevel\"];\n  const NORMAL_CLIP = {};\n  const 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      const width = this.ctx.canvas.width;\n      const 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        const 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      this._combinedScaleFactor = Math.hypot(\n        this.baseTransform[0],\n        this.baseTransform[2]\n      );\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      const argsArray = operatorList.argsArray;\n      const fnArray = operatorList.fnArray;\n      let i = executionStartIdx || 0;\n      const argsArrayLen = argsArray.length;\n\n      // Sometimes the OperatorList to execute is empty.\n      if (argsArrayLen === i) {\n        return i;\n      }\n\n      const chunkOperations =\n        argsArrayLen - i > EXECUTION_STEPS &&\n        typeof continueCallback === \"function\";\n      const endTime = chunkOperations ? Date.now() + EXECUTION_TIME : 0;\n      let steps = 0;\n\n      const commonObjs = this.commonObjs;\n      const objs = this.objs;\n      let 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      while (this.stateStack.length || this.current.activeSMask !== null) {\n        this.restore();\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      const 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 (let i = 0, ii = states.length; i < ii; i++) {\n        const state = states[i];\n        const key = state[0];\n        const 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          case \"TR\":\n            this.current.transferMaps = value;\n        }\n      }\n    },\n    beginSMaskGroup: function CanvasGraphics_beginSMaskGroup() {\n      const activeSMask = this.current.activeSMask;\n      const drawnWidth = activeSMask.canvas.width;\n      const drawnHeight = activeSMask.canvas.height;\n      const cacheId = \"smaskGroupAt\" + this.groupLevel;\n      const scratchCanvas = this.cachedCanvases.getCanvas(\n        cacheId,\n        drawnWidth,\n        drawnHeight,\n        true\n      );\n\n      const currentCtx = this.ctx;\n      const currentTransform = currentCtx.mozCurrentTransform;\n      this.ctx.save();\n\n      const 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      const 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      const 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_resumeSMaskGroup() {\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      const groupCtx = this.current.resumeSMaskCtx;\n      const currentCtx = this.ctx;\n      this.ctx = groupCtx;\n      this.groupStack.push(currentCtx);\n      this.groupLevel++;\n    },\n    endSMaskGroup: function CanvasGraphics_endSMaskGroup() {\n      const 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      const 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      const 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      } else {\n        // We've finished all the SMask groups, reflect that in our state.\n        this.current.activeSMask = 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      const ctx = this.ctx;\n      const current = this.current;\n      let x = current.x,\n        y = current.y;\n      for (let 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            const width = args[j++];\n            const height = args[j++];\n\n            const xw = x + width;\n            const yh = y + height;\n            ctx.moveTo(x, y);\n            if (width === 0 || height === 0) {\n              ctx.lineTo(xw, yh);\n            } else {\n              ctx.lineTo(xw, y);\n              ctx.lineTo(xw, yh);\n              ctx.lineTo(x, yh);\n            }\n\n            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      const ctx = this.ctx;\n      const 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 (this.contentVisible) {\n        if (typeof strokeColor === \"object\" && strokeColor?.getPattern) {\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,\n          // so we must scale it. To properly fix this we should be using a\n          // pattern transform instead (see #10955).\n          const transform = ctx.mozCurrentTransform;\n          const scale = Util.singularValueDecompose2dScale(transform)[0];\n          ctx.strokeStyle = strokeColor.getPattern(ctx, this);\n          const lineWidth = this.getSinglePixelWidth();\n          const scaledLineWidth = this.current.lineWidth * scale;\n          if (lineWidth < 0 && -lineWidth >= scaledLineWidth) {\n            ctx.resetTransform();\n            ctx.lineWidth = Math.round(this._combinedScaleFactor);\n          } else {\n            ctx.lineWidth = Math.max(lineWidth, scaledLineWidth);\n          }\n          ctx.stroke();\n          ctx.restore();\n        } else {\n          const lineWidth = this.getSinglePixelWidth();\n          if (lineWidth < 0 && -lineWidth >= this.current.lineWidth) {\n            // The current transform will transform a square pixel into a\n            // parallelogram where both heights are lower than 1 and not equal.\n            ctx.save();\n            ctx.resetTransform();\n            ctx.lineWidth = Math.round(this._combinedScaleFactor);\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(lineWidth, this.current.lineWidth);\n            ctx.stroke();\n          }\n        }\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      const ctx = this.ctx;\n      const fillColor = this.current.fillColor;\n      const isPatternFill = this.current.patternFill;\n      let 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.contentVisible) {\n        if (this.pendingEOFill) {\n          ctx.fill(\"evenodd\");\n          this.pendingEOFill = false;\n        } else {\n          ctx.fill();\n        }\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      const paths = this.pendingTextPaths;\n      const ctx = this.ctx;\n      if (paths === undefined) {\n        ctx.beginPath();\n        return;\n      }\n\n      ctx.save();\n      ctx.beginPath();\n      for (let i = 0; i < paths.length; i++) {\n        const 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      const fontObj = this.commonObjs.get(fontRefName);\n      const current = this.current;\n\n      if (!fontObj) {\n        throw new Error(`Can't find font for ${fontRefName}`);\n      }\n      current.fontMatrix = fontObj.fontMatrix || 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      const 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      const italic = fontObj.italic ? \"italic\" : \"normal\";\n      const 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, resetLineWidthToOne) {\n      const ctx = this.ctx;\n      const current = this.current;\n      const font = current.font;\n      const textRenderingMode = current.textRenderingMode;\n      const fontSize = current.fontSize / current.fontSizeScale;\n      const fillStrokeMode =\n        textRenderingMode & TextRenderingMode.FILL_STROKE_MASK;\n      const isAddToPathSet = !!(\n        textRenderingMode & TextRenderingMode.ADD_TO_PATH_FLAG\n      );\n      const patternFill = current.patternFill && !font.missingFile;\n\n      let 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          if (resetLineWidthToOne) {\n            ctx.resetTransform();\n            ctx.lineWidth = Math.round(this._combinedScaleFactor);\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          if (resetLineWidthToOne) {\n            ctx.save();\n            ctx.moveTo(x, y);\n            ctx.resetTransform();\n            ctx.lineWidth = Math.round(this._combinedScaleFactor);\n            ctx.strokeText(character, 0, 0);\n            ctx.restore();\n          } else {\n            ctx.strokeText(character, x, y);\n          }\n        }\n      }\n\n      if (isAddToPathSet) {\n        const 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      const data = ctx.getImageData(0, 0, 10, 10).data;\n      let enabled = false;\n      for (let 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      const current = this.current;\n      const font = current.font;\n      if (font.isType3Font) {\n        return this.showType3Text(glyphs);\n      }\n\n      const fontSize = current.fontSize;\n      if (fontSize === 0) {\n        return undefined;\n      }\n\n      const ctx = this.ctx;\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 glyphsLength = glyphs.length;\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      const 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      let lineWidth = current.lineWidth;\n      let resetLineWidthToOne = false;\n      const scale = current.textMatrixScale;\n      if (scale === 0 || lineWidth === 0) {\n        const 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();\n          resetLineWidthToOne = lineWidth < 0;\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      let x = 0,\n        i;\n      for (i = 0; i < glyphsLength; ++i) {\n        const glyph = glyphs[i];\n        if (isNum(glyph)) {\n          x += (spacingDir * glyph * fontSize) / 1000;\n          continue;\n        }\n\n        let restoreNeeded = false;\n        const spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;\n        const character = glyph.fontChar;\n        const accent = glyph.accent;\n        let scaledX, scaledY;\n        let width = glyph.width;\n        if (vertical) {\n          const vmetric = glyph.vmetric || defaultVMetrics;\n          const vx =\n            -(glyph.vmetric ? vmetric[1] : width * 0.5) * 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 (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          const measuredWidth =\n            ((ctx.measureText(character).width * 1000) / fontSize) *\n            fontSizeScale;\n          if (width < measuredWidth && this.isFontSubpixelAAEnabled) {\n            const 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 (this.contentVisible && (glyph.isInFont || font.missingFile)) {\n          if (simpleFillText && !accent) {\n            // common case\n            ctx.fillText(character, scaledX, scaledY);\n          } else {\n            this.paintChar(\n              character,\n              scaledX,\n              scaledY,\n              patternTransform,\n              resetLineWidthToOne\n            );\n            if (accent) {\n              const scaledAccentX =\n                scaledX + (fontSize * accent.offset.x) / fontSizeScale;\n              const scaledAccentY =\n                scaledY - (fontSize * accent.offset.y) / fontSizeScale;\n              this.paintChar(\n                accent.fontChar,\n                scaledAccentX,\n                scaledAccentY,\n                patternTransform,\n                resetLineWidthToOne\n              );\n            }\n          }\n        }\n\n        let 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      const ctx = this.ctx;\n      const current = this.current;\n      const font = current.font;\n      const fontSize = current.fontSize;\n      const fontDirection = current.fontDirection;\n      const spacingDir = font.vertical ? 1 : -1;\n      const charSpacing = current.charSpacing;\n      const wordSpacing = current.wordSpacing;\n      const textHScale = current.textHScale * fontDirection;\n      const fontMatrix = current.fontMatrix || FONT_IDENTITY_MATRIX;\n      const glyphsLength = glyphs.length;\n      const isTextInvisible =\n        current.textRenderingMode === TextRenderingMode.INVISIBLE;\n      let 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        const spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;\n        const operatorList = font.charProcOperatorList[glyph.operatorListId];\n        if (!operatorList) {\n          warn(`Type3 character \"${glyph.operatorListId}\" is not available.`);\n          continue;\n        }\n        if (this.contentVisible) {\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\n        const 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      let pattern;\n      if (IR[0] === \"TilingPattern\") {\n        const color = IR[1];\n        const baseTransform =\n          this.baseTransform || this.ctx.mozCurrentTransform.slice();\n        const 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      const color = Util.makeHexColor(r, g, b);\n      this.ctx.strokeStyle = color;\n      this.current.strokeColor = color;\n    },\n    setFillRGBColor: function CanvasGraphics_setFillRGBColor(r, g, b) {\n      const color = Util.makeHexColor(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      if (!this.contentVisible) {\n        return;\n      }\n      const ctx = this.ctx;\n\n      this.save();\n      const pattern = getShadingPatternFromIR(patternIR);\n      ctx.fillStyle = pattern.getPattern(ctx, this, true);\n\n      const inv = ctx.mozCurrentTransformInverse;\n      if (inv) {\n        const canvas = ctx.canvas;\n        const width = canvas.width;\n        const height = canvas.height;\n\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\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        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      if (!this.contentVisible) {\n        return;\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        const width = bbox[2] - bbox[0];\n        const 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      if (!this.contentVisible) {\n        return;\n      }\n      this.restore();\n      this.baseTransform = this.baseTransformStack.pop();\n    },\n\n    beginGroup: function CanvasGraphics_beginGroup(group) {\n      if (!this.contentVisible) {\n        return;\n      }\n\n      this.save();\n      const 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      const 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      let bounds = Util.getAxialAlignedBoundingBox(\n        group.bbox,\n        currentCtx.mozCurrentTransform\n      );\n      // Clip the bounding box to the current canvas.\n      const 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      const offsetX = Math.floor(bounds[0]);\n      const offsetY = Math.floor(bounds[1]);\n      let drawnWidth = Math.max(Math.ceil(bounds[2]) - offsetX, 1);\n      let drawnHeight = Math.max(Math.ceil(bounds[3]) - offsetY, 1);\n      let 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      let 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      const scratchCanvas = this.cachedCanvases.getCanvas(\n        cacheId,\n        drawnWidth,\n        drawnHeight,\n        true\n      );\n      const 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      if (!this.contentVisible) {\n        return;\n      }\n      this.groupLevel--;\n      const 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        const width = rect[2] - rect[0];\n        const 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      if (!this.contentVisible) {\n        return;\n      }\n      const ctx = this.ctx;\n      const width = img.width,\n        height = img.height;\n      const fillColor = this.current.fillColor;\n      const isPatternFill = this.current.patternFill;\n\n      const 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?.compiled) {\n        glyph.compiled(ctx);\n        return;\n      }\n\n      const maskCanvas = this.cachedCanvases.getCanvas(\n        \"maskCanvas\",\n        width,\n        height\n      );\n      const 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(\n      imgData,\n      scaleX,\n      skewX = 0,\n      skewY = 0,\n      scaleY,\n      positions\n    ) {\n      if (!this.contentVisible) {\n        return;\n      }\n      const width = imgData.width;\n      const height = imgData.height;\n      const fillColor = this.current.fillColor;\n      const isPatternFill = this.current.patternFill;\n\n      const maskCanvas = this.cachedCanvases.getCanvas(\n        \"maskCanvas\",\n        width,\n        height\n      );\n      const 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      const ctx = this.ctx;\n      for (let i = 0, ii = positions.length; i < ii; i += 2) {\n        ctx.save();\n        ctx.transform(\n          scaleX,\n          skewX,\n          skewY,\n          scaleY,\n          positions[i],\n          positions[i + 1]\n        );\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      if (!this.contentVisible) {\n        return;\n      }\n      const ctx = this.ctx;\n\n      const fillColor = this.current.fillColor;\n      const isPatternFill = this.current.patternFill;\n      for (let i = 0, ii = images.length; i < ii; i++) {\n        const image = images[i];\n        const width = image.width,\n          height = image.height;\n\n        const maskCanvas = this.cachedCanvases.getCanvas(\n          \"maskCanvas\",\n          width,\n          height\n        );\n        const 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      if (!this.contentVisible) {\n        return;\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      this.paintInlineImageXObject(imgData);\n    },\n\n    paintImageXObjectRepeat: function CanvasGraphics_paintImageXObjectRepeat(\n      objId,\n      scaleX,\n      scaleY,\n      positions\n    ) {\n      if (!this.contentVisible) {\n        return;\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      const width = imgData.width;\n      const height = imgData.height;\n      const map = [];\n      for (let 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      if (!this.contentVisible) {\n        return;\n      }\n      const width = imgData.width;\n      const height = imgData.height;\n      const ctx = this.ctx;\n\n      this.save();\n      // scale the image to the unit square\n      ctx.scale(1 / width, -1 / height);\n\n      const currentTransform = ctx.mozCurrentTransformInverse;\n      const a = currentTransform[0],\n        b = currentTransform[1];\n      let widthScale = Math.max(Math.sqrt(a * a + b * b), 1);\n      const c = currentTransform[2],\n        d = currentTransform[3];\n      let heightScale = Math.max(Math.sqrt(c * c + d * d), 1);\n\n      let imgToPaint, tmpCanvas, tmpCtx;\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        tmpCtx = tmpCanvas.context;\n        putBinaryImageData(tmpCtx, imgData, this.current.transferMaps);\n        imgToPaint = tmpCanvas.canvas;\n      }\n\n      let paintWidth = width,\n        paintHeight = height;\n      let 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        let 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        const 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      if (!this.contentVisible) {\n        return;\n      }\n      const ctx = this.ctx;\n      const w = imgData.width;\n      const h = imgData.height;\n\n      const tmpCanvas = this.cachedCanvases.getCanvas(\"inlineImage\", w, h);\n      const tmpCtx = tmpCanvas.context;\n      putBinaryImageData(tmpCtx, imgData, this.current.transferMaps);\n\n      for (let i = 0, ii = map.length; i < ii; i++) {\n        const 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          const 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      if (!this.contentVisible) {\n        return;\n      }\n      this.ctx.fillRect(0, 0, 1, 1);\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      this.markedContentStack.push({\n        visible: true,\n      });\n    },\n    beginMarkedContentProps: function CanvasGraphics_beginMarkedContentProps(\n      tag,\n      properties\n    ) {\n      if (tag === \"OC\") {\n        this.markedContentStack.push({\n          visible: this.optionalContentConfig.isVisible(properties),\n        });\n      } else {\n        this.markedContentStack.push({\n          visible: true,\n        });\n      }\n      this.contentVisible = this.isContentVisible();\n    },\n    endMarkedContent: function CanvasGraphics_endMarkedContent() {\n      this.markedContentStack.pop();\n      this.contentVisible = this.isContentVisible();\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      const 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() {\n      if (this._cachedGetSinglePixelWidth === null) {\n        // If transform is [a b] then a pixel (square) is transformed\n        //                 [c d]\n        // into a parallelogram: its area is the abs value of the determinant.\n        // This parallelogram has 2 heights:\n        //  - Area / |col_1|;\n        //  - Area / |col_2|.\n        // so in order to get a height of at least 1, pixel height\n        // must be computed as followed:\n        //  h = max(sqrt(a² + c²) / |det(M)|, sqrt(b² + d²) / |det(M)|).\n        // This is equivalent to:\n        //  h = max(|line_1_inv(M)|, |line_2_inv(M)|)\n        const m = this.ctx.mozCurrentTransform;\n\n        const absDet = Math.abs(m[0] * m[3] - m[2] * m[1]);\n        const sqNorm1 = m[0] ** 2 + m[2] ** 2;\n        const sqNorm2 = m[1] ** 2 + m[3] ** 2;\n        const pixelHeight = Math.sqrt(Math.max(sqNorm1, sqNorm2)) / absDet;\n        if (\n          sqNorm1 !== sqNorm2 &&\n          this._combinedScaleFactor * pixelHeight > 1\n        ) {\n          // The parallelogram isn't a square and at least one height\n          // is lower than 1 so the resulting line width must be 1\n          // but it cannot be achieved with one scale: when scaling a pixel\n          // we'll get a rectangle (see issue #12295).\n          // For example with matrix [0.001 0, 0, 100], a pixel is transformed\n          // in a rectangle 0.001x100. If we just scale by 1000 (to have a 1)\n          // then we'll get a rectangle 1x1e5 which is wrong.\n          // In this case, we must reset the transform, set linewidth to 1\n          // and then stroke.\n          this._cachedGetSinglePixelWidth = -(\n            this._combinedScaleFactor * pixelHeight\n          );\n        } else if (absDet > Number.EPSILON) {\n          // The multiplication by the constant 1.0000001 is here to have\n          // a number slightly greater than what we \"exactly\" want.\n          this._cachedGetSinglePixelWidth = pixelHeight * 1.0000001;\n        } else {\n          // Matrix is non-invertible.\n          this._cachedGetSinglePixelWidth = 1;\n        }\n      }\n\n      return this._cachedGetSinglePixelWidth;\n    },\n    getCanvasPosition: function CanvasGraphics_getCanvasPosition(x, y) {\n      const 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    isContentVisible: function CanvasGraphics_isContentVisible() {\n      for (let i = this.markedContentStack.length - 1; i >= 0; i--) {\n        if (!this.markedContentStack[i].visible) {\n          return false;\n        }\n      }\n      return true;\n    },\n  };\n\n  for (const 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\nconst 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    const type = raw[1];\n    const bbox = raw[2];\n    const colorStops = raw[3];\n    const p0 = raw[4];\n    const p1 = raw[5];\n    const r0 = raw[6];\n    const r1 = raw[7];\n    return {\n      getPattern: function RadialAxial_getPattern(ctx) {\n        applyBoundingBox(ctx, bbox);\n        let 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 (let i = 0, ii = colorStops.length; i < ii; ++i) {\n          const c = colorStops[i];\n          grad.addColorStop(c[0], c[1]);\n        }\n        return grad;\n      },\n    };\n  },\n};\n\nconst createMeshCanvas = (function createMeshCanvasClosure() {\n  function drawTriangle(data, context, p1, p2, p3, c1, c2, c3) {\n    // Very basic Gouraud-shaded triangle rasterization algorithm.\n    const coords = context.coords,\n      colors = context.colors;\n    const bytes = data.data,\n      rowSize = data.width * 4;\n    let 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    const x1 = (coords[p1] + context.offsetX) * context.scaleX;\n    const y1 = (coords[p1 + 1] + context.offsetY) * context.scaleY;\n    const x2 = (coords[p2] + context.offsetX) * context.scaleX;\n    const y2 = (coords[p2 + 1] + context.offsetY) * context.scaleY;\n    const x3 = (coords[p3] + context.offsetX) * context.scaleX;\n    const y3 = (coords[p3 + 1] + context.offsetY) * context.scaleY;\n    if (y1 >= y3) {\n      return;\n    }\n    const c1r = colors[c1],\n      c1g = colors[c1 + 1],\n      c1b = colors[c1 + 2];\n    const c2r = colors[c2],\n      c2g = colors[c2 + 1],\n      c2b = colors[c2 + 2];\n    const c3r = colors[c3],\n      c3g = colors[c3 + 1],\n      c3b = colors[c3 + 2];\n\n    const minY = Math.round(y1),\n      maxY = Math.round(y3);\n    let xa, car, cag, cab;\n    let xb, cbr, cbg, cbb;\n    for (let 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      const x1_ = Math.round(Math.min(xa, xb));\n      const x2_ = Math.round(Math.max(xa, xb));\n      let j = rowSize * y + x1_ * 4;\n      for (let 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    const ps = figure.coords;\n    const cs = figure.colors;\n    let i, ii;\n    switch (figure.type) {\n      case \"lattice\":\n        const verticesPerRow = figure.verticesPerRow;\n        const rows = Math.floor(ps.length / verticesPerRow) - 1;\n        const cols = verticesPerRow - 1;\n        for (i = 0; i < rows; i++) {\n          let q = i * verticesPerRow;\n          for (let 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    const EXPECTED_SCALE = 1.1;\n    // MAX_PATTERN_SIZE is used to avoid OOM situation.\n    const 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    const BORDER_SIZE = 2;\n\n    const offsetX = Math.floor(bounds[0]);\n    const offsetY = Math.floor(bounds[1]);\n    const boundsWidth = Math.ceil(bounds[2]) - offsetX;\n    const boundsHeight = Math.ceil(bounds[3]) - offsetY;\n\n    const width = Math.min(\n      Math.ceil(Math.abs(boundsWidth * combinesScale[0] * EXPECTED_SCALE)),\n      MAX_PATTERN_SIZE\n    );\n    const height = Math.min(\n      Math.ceil(Math.abs(boundsHeight * combinesScale[1] * EXPECTED_SCALE)),\n      MAX_PATTERN_SIZE\n    );\n    const scaleX = boundsWidth / width;\n    const scaleY = boundsHeight / height;\n\n    const context = {\n      coords,\n      colors,\n      offsetX: -offsetX,\n      offsetY: -offsetY,\n      scaleX: 1 / scaleX,\n      scaleY: 1 / scaleY,\n    };\n\n    const paddedWidth = width + BORDER_SIZE * 2;\n    const paddedHeight = height + BORDER_SIZE * 2;\n\n    let 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      const tmpCtx = tmpCanvas.context;\n\n      const data = tmpCtx.createImageData(width, height);\n      if (backgroundColor) {\n        const 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    const coords = raw[2];\n    const colors = raw[3];\n    const figures = raw[4];\n    const bounds = raw[5];\n    const matrix = raw[6];\n    const bbox = raw[7];\n    const background = raw[8];\n    return {\n      getPattern: function Mesh_getPattern(ctx, owner, shadingFill) {\n        applyBoundingBox(ctx, bbox);\n        let 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            const 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        const 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      getPattern: function Dummy_fromIR_getPattern() {\n        return \"hotpink\";\n      },\n    };\n  },\n};\n\nfunction getShadingPatternFromIR(raw) {\n  const shadingIR = ShadingIRs[raw[0]];\n  if (!shadingIR) {\n    throw new Error(`Unknown IR type: ${raw[0]}`);\n  }\n  return shadingIR.fromIR(raw);\n}\n\n/**\n * @type {any}\n */\nconst TilingPattern = (function TilingPatternClosure() {\n  const PaintType = {\n    COLORED: 1,\n    UNCOLORED: 2,\n  };\n\n  const 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.ctx = ctx;\n  }\n\n  TilingPattern.prototype = {\n    createPatternCanvas: function TilinPattern_createPatternCanvas(owner) {\n      const operatorList = this.operatorList;\n      const bbox = this.bbox;\n      const xstep = this.xstep;\n      const ystep = this.ystep;\n      const paintType = this.paintType;\n      const tilingType = this.tilingType;\n      const color = this.color;\n      const 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      const 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      const matrixScale = Util.singularValueDecompose2dScale(this.matrix);\n      const curMatrixScale = Util.singularValueDecompose2dScale(\n        this.baseTransform\n      );\n      const 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      const dimx = this.getSizeAndScale(\n        xstep,\n        this.ctx.canvas.width,\n        combinedScale[0]\n      );\n      const dimy = this.getSizeAndScale(\n        ystep,\n        this.ctx.canvas.height,\n        combinedScale[1]\n      );\n\n      const tmpCanvas = owner.cachedCanvases.getCanvas(\n        \"pattern\",\n        dimx.size,\n        dimy.size,\n        true\n      );\n      const tmpCtx = tmpCanvas.context;\n      const 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      const maxSize = Math.max(MAX_PATTERN_SIZE, realOutputSize);\n      let 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        const bboxWidth = x1 - x0;\n        const 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          const 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          const cssColor = Util.makeHexColor(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      const 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\n/**\n * @typedef {Object} GlobalWorkerOptionsType\n * @property {Worker | null} workerPort - Defines global port for worker\n *   process. Overrides the `workerSrc` option.\n * @property {string} workerSrc - A string containing the path and filename\n *   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 */\n\n/** @type {GlobalWorkerOptionsType} */\nconst GlobalWorkerOptions = Object.create(null);\n\nGlobalWorkerOptions.workerPort =\n  GlobalWorkerOptions.workerPort === undefined\n    ? null\n    : GlobalWorkerOptions.workerPort;\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\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, objectFromEntries } from \"../shared/util.js\";\nimport { SimpleXMLParser } from \"../shared/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({ lowerCaseName: true });\n    const xmlDocument = parser.parseFromString(data);\n\n    this._metadataMap = new Map();\n\n    if (xmlDocument) {\n      this._parse(xmlDocument);\n    }\n    this._data = data;\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  _getSequence(entry) {\n    const name = entry.nodeName;\n    if (name !== \"rdf:bag\" && name !== \"rdf:seq\" && name !== \"rdf:alt\") {\n      return null;\n    }\n\n    return entry.childNodes.filter(node => node.nodeName === \"rdf:li\");\n  }\n\n  _getCreators(entry) {\n    if (entry.nodeName !== \"dc:creator\") {\n      return false;\n    }\n    if (!entry.hasChildNodes()) {\n      return true;\n    }\n\n    // Child must be a Bag (unordered array) or a Seq.\n    const seqNode = entry.childNodes[0];\n    const authors = this._getSequence(seqNode) || [];\n    this._metadataMap.set(\n      entry.nodeName,\n      authors.map(node => node.textContent.trim())\n    );\n\n    return true;\n  }\n\n  _parse(xmlDocument) {\n    let rdf = xmlDocument.documentElement;\n\n    if (rdf.nodeName !== \"rdf:rdf\") {\n      // Wrapped in <xmpmeta>\n      rdf = rdf.firstChild;\n      while (rdf && rdf.nodeName !== \"rdf:rdf\") {\n        rdf = rdf.nextSibling;\n      }\n    }\n\n    if (!rdf || rdf.nodeName !== \"rdf:rdf\" || !rdf.hasChildNodes()) {\n      return;\n    }\n\n    for (const desc of rdf.childNodes) {\n      if (desc.nodeName !== \"rdf:description\") {\n        continue;\n      }\n\n      for (const entry of desc.childNodes) {\n        const name = entry.nodeName;\n        if (name === \"#text\") {\n          continue;\n        }\n        if (this._getCreators(entry)) {\n          continue;\n        }\n        this._metadataMap.set(name, entry.textContent.trim());\n      }\n    }\n  }\n\n  getRaw() {\n    return this._data;\n  }\n\n  get(name) {\n    return this._metadataMap.get(name) ?? null;\n  }\n\n  getAll() {\n    return objectFromEntries(this._metadataMap);\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\nimport { encodeToXmlString } from \"./util.js\";\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.fromCodePoint(parseInt(entity.substring(2), 16));\n      } else if (entity.substring(0, 1) === \"#\") {\n        return String.fromCodePoint(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  /**\n   * Search a node in the tree with the given path\n   * foo.bar[nnn], i.e. find the nnn-th node named\n   * bar under a node named foo.\n   *\n   * @param {Array} paths - an array of objects as\n   * returned by {parseXFAPath}.\n   * @param {number} pos - the current position in\n   * the paths array.\n   * @returns {SimpleDOMNode} The node corresponding\n   * to the path or null if not found.\n   */\n  searchNode(paths, pos) {\n    if (pos >= paths.length) {\n      return this;\n    }\n\n    const component = paths[pos];\n    const stack = [];\n    let node = this;\n\n    while (true) {\n      if (component.name === node.nodeName) {\n        if (component.pos === 0) {\n          const res = node.searchNode(paths, pos + 1);\n          if (res !== null) {\n            return res;\n          }\n        } else if (stack.length === 0) {\n          return null;\n        } else {\n          const [parent] = stack.pop();\n          let siblingPos = 0;\n          for (const child of parent.childNodes) {\n            if (component.name === child.nodeName) {\n              if (siblingPos === component.pos) {\n                return child.searchNode(paths, pos + 1);\n              }\n              siblingPos++;\n            }\n          }\n          // We didn't find the correct sibling\n          // so just return the first found node\n          return node.searchNode(paths, pos + 1);\n        }\n      }\n\n      if (node.childNodes && node.childNodes.length !== 0) {\n        stack.push([node, 0]);\n        node = node.childNodes[0];\n      } else if (stack.length === 0) {\n        return null;\n      } else {\n        while (stack.length !== 0) {\n          const [parent, currentPos] = stack.pop();\n          const newPos = currentPos + 1;\n          if (newPos < parent.childNodes.length) {\n            stack.push([parent, newPos]);\n            node = parent.childNodes[newPos];\n            break;\n          }\n        }\n        if (stack.length === 0) {\n          return null;\n        }\n      }\n    }\n  }\n\n  dump(buffer) {\n    if (this.nodeName === \"#text\") {\n      buffer.push(encodeToXmlString(this.nodeValue));\n      return;\n    }\n\n    buffer.push(`<${this.nodeName}`);\n    if (this.attributes) {\n      for (const attribute of this.attributes) {\n        buffer.push(\n          ` ${attribute.name}=\"${encodeToXmlString(attribute.value)}\"`\n        );\n      }\n    }\n    if (this.hasChildNodes()) {\n      buffer.push(\">\");\n      for (const child of this.childNodes) {\n        child.dump(buffer);\n      }\n      buffer.push(`</${this.nodeName}>`);\n    } else if (this.nodeValue) {\n      buffer.push(`>${encodeToXmlString(this.nodeValue)}</${this.nodeName}>`);\n    } else {\n      buffer.push(\"/>\");\n    }\n  }\n}\n\nclass SimpleXMLParser extends XMLParserBase {\n  constructor({ hasAttributes = false, lowerCaseName = false }) {\n    super();\n    this._currentFragment = null;\n    this._stack = null;\n    this._errorCode = XMLParserErrorCode.NoError;\n    this._hasAttributes = hasAttributes;\n    this._lowerCaseName = lowerCaseName;\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    if (this._lowerCaseName) {\n      name = name.toLowerCase();\n    }\n    const node = new SimpleDOMNode(name);\n    node.childNodes = [];\n    if (this._hasAttributes) {\n      node.attributes = attributes;\n    }\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 { SimpleDOMNode, SimpleXMLParser };\n","/* Copyright 2020 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 */\nimport { objectFromEntries, warn } from \"../shared/util.js\";\n\nclass OptionalContentGroup {\n  constructor(name, intent) {\n    this.visible = true;\n    this.name = name;\n    this.intent = intent;\n  }\n}\n\nclass OptionalContentConfig {\n  constructor(data) {\n    this.name = null;\n    this.creator = null;\n    this._order = null;\n    this._groups = new Map();\n\n    if (data === null) {\n      return;\n    }\n    this.name = data.name;\n    this.creator = data.creator;\n    this._order = data.order;\n    for (const group of data.groups) {\n      this._groups.set(\n        group.id,\n        new OptionalContentGroup(group.name, group.intent)\n      );\n    }\n\n    if (data.baseState === \"OFF\") {\n      for (const group of this._groups) {\n        group.visible = false;\n      }\n    }\n\n    for (const on of data.on) {\n      this._groups.get(on).visible = true;\n    }\n\n    for (const off of data.off) {\n      this._groups.get(off).visible = false;\n    }\n  }\n\n  isVisible(group) {\n    if (group.type === \"OCG\") {\n      if (!this._groups.has(group.id)) {\n        warn(`Optional content group not found: ${group.id}`);\n        return true;\n      }\n      return this._groups.get(group.id).visible;\n    } else if (group.type === \"OCMD\") {\n      // Per the spec, the expression should be preferred if available. Until\n      // we implement this, just fallback to using the group policy for now.\n      if (group.expression) {\n        warn(\"Visibility expression not supported yet.\");\n      }\n      if (!group.policy || group.policy === \"AnyOn\") {\n        // Default\n        for (const id of group.ids) {\n          if (!this._groups.has(id)) {\n            warn(`Optional content group not found: ${id}`);\n            return true;\n          }\n          if (this._groups.get(id).visible) {\n            return true;\n          }\n        }\n        return false;\n      } else if (group.policy === \"AllOn\") {\n        for (const id of group.ids) {\n          if (!this._groups.has(id)) {\n            warn(`Optional content group not found: ${id}`);\n            return true;\n          }\n          if (!this._groups.get(id).visible) {\n            return false;\n          }\n        }\n        return true;\n      } else if (group.policy === \"AnyOff\") {\n        for (const id of group.ids) {\n          if (!this._groups.has(id)) {\n            warn(`Optional content group not found: ${id}`);\n            return true;\n          }\n          if (!this._groups.get(id).visible) {\n            return true;\n          }\n        }\n        return false;\n      } else if (group.policy === \"AllOff\") {\n        for (const id of group.ids) {\n          if (!this._groups.has(id)) {\n            warn(`Optional content group not found: ${id}`);\n            return true;\n          }\n          if (this._groups.get(id).visible) {\n            return false;\n          }\n        }\n        return true;\n      }\n      warn(`Unknown optional content policy ${group.policy}.`);\n      return true;\n    }\n    warn(`Unknown group type ${group.type}.`);\n    return true;\n  }\n\n  setVisibility(id, visible = true) {\n    if (!this._groups.has(id)) {\n      warn(`Optional content group not found: ${id}`);\n      return;\n    }\n    this._groups.get(id).visible = !!visible;\n  }\n\n  getOrder() {\n    if (!this._groups.size) {\n      return null;\n    }\n    if (this._order) {\n      return this._order.slice();\n    }\n    return Array.from(this._groups.keys());\n  }\n\n  getGroups() {\n    if (!this._groups.size) {\n      return null;\n    }\n    return objectFromEntries(this._groups);\n  }\n\n  getGroup(id) {\n    return this._groups.get(id) || null;\n  }\n}\n\nexport { OptionalContentConfig };\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, 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?.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?._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?.onProgress) {\n        firstReader.onProgress({ loaded: evt.loaded });\n      }\n    } else {\n      const fullReader = this._fullRequestReader;\n      if (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\nconst WebGLUtils = (function WebGLUtilsClosure() {\n  function loadShader(gl, code, shaderType) {\n    const shader = gl.createShader(shaderType);\n    gl.shaderSource(shader, code);\n    gl.compileShader(shader);\n    const compiled = gl.getShaderParameter(shader, gl.COMPILE_STATUS);\n    if (!compiled) {\n      const 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    const program = gl.createProgram();\n    for (let i = 0, ii = shaders.length; i < ii; ++i) {\n      gl.attachShader(program, shaders[i]);\n    }\n    gl.linkProgram(program);\n    const linked = gl.getProgramParameter(program, gl.LINK_STATUS);\n    if (!linked) {\n      const 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    const 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  let 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  const 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  const 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  let smaskCache = null;\n\n  function initSmaskGL() {\n    generateGL();\n    const canvas = currentCanvas;\n    currentCanvas = null;\n    const gl = currentGL;\n    currentGL = null;\n\n    // setup a GLSL program\n    const vertexShader = createVertexShader(gl, smaskVertexShaderCode);\n    const fragmentShader = createFragmentShader(gl, smaskFragmentShaderCode);\n    const program = createProgram(gl, [vertexShader, fragmentShader]);\n    gl.useProgram(program);\n\n    const 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    const texCoordLocation = gl.getAttribLocation(program, \"a_texCoord\");\n    const texLayerLocation = gl.getUniformLocation(program, \"u_image\");\n    const texMaskLocation = gl.getUniformLocation(program, \"u_mask\");\n\n    // provide texture coordinates for the rectangle.\n    const 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    const width = layer.width,\n      height = layer.height;\n\n    if (!smaskCache) {\n      initSmaskGL();\n    }\n    const 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    const texture = createTexture(gl, layer, gl.TEXTURE0);\n    const maskTexture = createTexture(gl, mask, gl.TEXTURE1);\n\n    // Create a buffer and put a single clipspace rectangle in\n    // it (2 triangles)\n    const 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  const 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  const figuresFragmentShaderCode =\n    \"\\\n  precision mediump float;                                      \\\n                                                                \\\n  varying vec4 v_color;                                         \\\n                                                                \\\n  void main() {                                                 \\\n    gl_FragColor = v_color;                                     \\\n  }                                                             \";\n\n  let figuresCache = null;\n\n  function initFiguresGL() {\n    generateGL();\n    const canvas = currentCanvas;\n    currentCanvas = null;\n    const gl = currentGL;\n    currentGL = null;\n\n    // setup a GLSL program\n    const vertexShader = createVertexShader(gl, figuresVertexShaderCode);\n    const fragmentShader = createFragmentShader(gl, figuresFragmentShaderCode);\n    const program = createProgram(gl, [vertexShader, fragmentShader]);\n    gl.useProgram(program);\n\n    const 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    const 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    let count = 0;\n    for (let i = 0, ii = figures.length; i < ii; i++) {\n      switch (figures[i].type) {\n        case \"lattice\":\n          const rows =\n            (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    const coords = new Float32Array(count * 2);\n    const colors = new Uint8Array(count * 3);\n    const coordsMap = context.coords,\n      colorsMap = context.colors;\n    let pIndex = 0,\n      cIndex = 0;\n    for (let i = 0, ii = figures.length; i < ii; i++) {\n      const figure = figures[i],\n        ps = figure.coords,\n        cs = figure.colors;\n      switch (figure.type) {\n        case \"lattice\":\n          const cols = figure.verticesPerRow;\n          const rows = (ps.length / cols) | 0;\n          for (let row = 1; row < rows; row++) {\n            let offset = row * cols + 1;\n            for (let 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 (let 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    const 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    const 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?.canvas) {\n        smaskCache.canvas.width = 0;\n        smaskCache.canvas.height = 0;\n      }\n      if (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\nimport {\n  addLinkAttributes,\n  DOMSVGFactory,\n  getFilenameFromUrl,\n  LinkTarget,\n  PDFDateString,\n} from \"./display_utils.js\";\nimport {\n  AnnotationBorderStyleType,\n  AnnotationType,\n  assert,\n  stringToPDFString,\n  unreachable,\n  Util,\n  warn,\n} from \"../shared/util.js\";\nimport { AnnotationStorage } from \"./annotation_storage.js\";\nimport { ColorConverters } from \"../shared/scripting_utils.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 {AnnotationStorage} [annotationStorage]\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 * @property {boolean} [enableScripting]\n * @property {boolean} [hasJSActions]\n * @property {Object} [mouseState]\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(\n    parameters,\n    {\n      isRenderable = false,\n      ignoreBorder = false,\n      createQuadrilaterals = false,\n    } = {}\n  ) {\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    this.annotationStorage = parameters.annotationStorage;\n    this.enableScripting = parameters.enableScripting;\n    this.hasJSActions = parameters.hasJSActions;\n    this._mouseState = parameters.mouseState;\n\n    if (isRenderable) {\n      this.container = this._createContainer(ignoreBorder);\n    }\n    if (createQuadrilaterals) {\n      this.quadrilaterals = this._createQuadrilaterals(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.makeHexColor(\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 quadrilaterals from the annotation's quadpoints.\n   *\n   * @private\n   * @param {boolean} ignoreBorder\n   * @memberof AnnotationElement\n   * @returns {Array<HTMLSectionElement>}\n   */\n  _createQuadrilaterals(ignoreBorder = false) {\n    if (!this.data.quadPoints) {\n      return null;\n    }\n\n    const quadrilaterals = [];\n    const savedRect = this.data.rect;\n    for (const quadPoint of this.data.quadPoints) {\n      this.data.rect = [\n        quadPoint[2].x,\n        quadPoint[2].y,\n        quadPoint[1].x,\n        quadPoint[1].y,\n      ];\n      quadrilaterals.push(this._createContainer(ignoreBorder));\n    }\n    this.data.rect = savedRect;\n    return quadrilaterals;\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 {HTMLDivElement|HTMLImageElement|null} trigger\n   * @param {Object} data\n   * @memberof AnnotationElement\n   */\n  _createPopup(trigger, data) {\n    let container = this.container;\n    if (this.quadrilaterals) {\n      trigger = trigger || this.quadrilaterals;\n      container = this.quadrilaterals[0];\n    }\n\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 quadrilaterals of the annotation.\n   *\n   * @private\n   * @param {string} className\n   * @memberof AnnotationElement\n   * @returns {Array<HTMLSectionElement>}\n   */\n  _renderQuadrilaterals(className) {\n    if (\n      typeof PDFJSDev === \"undefined\" ||\n      PDFJSDev.test(\"!PRODUCTION || TESTING\")\n    ) {\n      assert(this.quadrilaterals, \"Missing quadrilaterals during rendering\");\n    }\n\n    this.quadrilaterals.forEach(quadrilateral => {\n      quadrilateral.className = className;\n    });\n    return this.quadrilaterals;\n  }\n\n  /**\n   * Render the annotation's HTML element(s).\n   *\n   * @public\n   * @memberof AnnotationElement\n   * @returns {HTMLSectionElement|Array<HTMLSectionElement>}\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      parameters.data.isTooltipOnly ||\n      (parameters.data.actions &&\n        (parameters.data.actions.Action ||\n          parameters.data.actions[\"Mouse Up\"] ||\n          parameters.data.actions[\"Mouse Down\"]))\n    );\n    super(parameters, { isRenderable, createQuadrilaterals: true });\n  }\n\n  render() {\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 if (data.dest) {\n      this._bindLink(link, data.dest);\n    } else if (\n      data.actions &&\n      (data.actions.Action ||\n        data.actions[\"Mouse Up\"] ||\n        data.actions[\"Mouse Down\"]) &&\n      this.enableScripting &&\n      this.hasJSActions\n    ) {\n      this._bindJSAction(link, data);\n    } else {\n      this._bindLink(link, \"\");\n    }\n\n    if (this.quadrilaterals) {\n      return this._renderQuadrilaterals(\"linkAnnotation\").map(\n        (quadrilateral, index) => {\n          const linkElement = index === 0 ? link : link.cloneNode();\n          quadrilateral.appendChild(linkElement);\n          return quadrilateral;\n        }\n      );\n    }\n\n    this.container.className = \"linkAnnotation\";\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.goToDestination(destination);\n      }\n      return false;\n    };\n    if (destination || destination === /* isTooltipOnly = */ \"\") {\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  /**\n   * Bind JS actions to the link element.\n   *\n   * @private\n   * @param {Object} link\n   * @param {Object} data\n   * @memberof LinkAnnotationElement\n   */\n  _bindJSAction(link, data) {\n    link.href = this.linkService.getAnchorUrl(\"\");\n    const map = new Map([\n      [\"Action\", \"onclick\"],\n      [\"Mouse Up\", \"onmouseup\"],\n      [\"Mouse Down\", \"onmousedown\"],\n    ]);\n    for (const name of Object.keys(data.actions)) {\n      const jsName = map.get(name);\n      if (!jsName) {\n        continue;\n      }\n      link[jsName] = () => {\n        this.linkService.eventBus?.dispatch(\"dispatcheventinsandbox\", {\n          source: this,\n          detail: {\n            id: data.id,\n            name,\n          },\n        });\n        return false;\n      };\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  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(image, this.data);\n    }\n\n    this.container.appendChild(image);\n    return this.container;\n  }\n}\n\nclass WidgetAnnotationElement extends AnnotationElement {\n  render() {\n    // Show only the container for unsupported field types.\n    if (this.data.alternativeText) {\n      this.container.title = this.data.alternativeText;\n    }\n\n    return this.container;\n  }\n\n  _getKeyModifier(event) {\n    return (\n      (navigator.platform.includes(\"Win\") && event.ctrlKey) ||\n      (navigator.platform.includes(\"Mac\") && event.metaKey)\n    );\n  }\n\n  _setEventListener(element, baseName, eventName, valueGetter) {\n    if (baseName.includes(\"mouse\")) {\n      // Mouse events\n      element.addEventListener(baseName, event => {\n        this.linkService.eventBus?.dispatch(\"dispatcheventinsandbox\", {\n          source: this,\n          detail: {\n            id: this.data.id,\n            name: eventName,\n            value: valueGetter(event),\n            shift: event.shiftKey,\n            modifier: this._getKeyModifier(event),\n          },\n        });\n      });\n    } else {\n      // Non mouse event\n      element.addEventListener(baseName, event => {\n        this.linkService.eventBus?.dispatch(\"dispatcheventinsandbox\", {\n          source: this,\n          detail: {\n            id: this.data.id,\n            name: eventName,\n            value: event.target.checked,\n          },\n        });\n      });\n    }\n  }\n\n  _setEventListeners(element, names, getter) {\n    for (const [baseName, eventName] of names) {\n      if (eventName === \"Action\" || this.data.actions?.[eventName]) {\n        this._setEventListener(element, baseName, eventName, getter);\n      }\n    }\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  render() {\n    const storage = this.annotationStorage;\n    const id = this.data.id;\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      const textContent = storage.getOrCreateValue(id, {\n        value: this.data.fieldValue,\n      }).value;\n      const elementData = {\n        userValue: null,\n        formattedValue: null,\n        beforeInputSelectionRange: null,\n        beforeInputValue: null,\n      };\n\n      if (this.data.multiLine) {\n        element = document.createElement(\"textarea\");\n        element.textContent = textContent;\n      } else {\n        element = document.createElement(\"input\");\n        element.type = \"text\";\n        element.setAttribute(\"value\", textContent);\n      }\n\n      elementData.userValue = textContent;\n      element.setAttribute(\"id\", id);\n\n      element.addEventListener(\"input\", function (event) {\n        storage.setValue(id, { value: event.target.value });\n      });\n\n      let blurListener = event => {\n        if (elementData.formattedValue) {\n          event.target.value = elementData.formattedValue;\n        }\n        event.target.setSelectionRange(0, 0);\n        elementData.beforeInputSelectionRange = null;\n      };\n\n      if (this.enableScripting && this.hasJSActions) {\n        element.addEventListener(\"focus\", event => {\n          if (elementData.userValue) {\n            event.target.value = elementData.userValue;\n          }\n        });\n\n        element.addEventListener(\"updatefromsandbox\", function (event) {\n          const { detail } = event;\n          const actions = {\n            value() {\n              elementData.userValue = detail.value || \"\";\n              storage.setValue(id, { value: elementData.userValue.toString() });\n              if (!elementData.formattedValue) {\n                event.target.value = elementData.userValue;\n              }\n            },\n            valueAsString() {\n              elementData.formattedValue = detail.valueAsString || \"\";\n              if (event.target !== document.activeElement) {\n                // Input hasn't the focus so display formatted string\n                event.target.value = elementData.formattedValue;\n              }\n              storage.setValue(id, {\n                formattedValue: elementData.formattedValue,\n              });\n            },\n            focus() {\n              setTimeout(() => event.target.focus({ preventScroll: false }), 0);\n            },\n            userName() {\n              // tooltip\n              event.target.title = detail.userName;\n            },\n            hidden() {\n              event.target.style.visibility = detail.hidden\n                ? \"hidden\"\n                : \"visible\";\n              storage.setValue(id, { hidden: detail.hidden });\n            },\n            editable() {\n              event.target.disabled = !detail.editable;\n            },\n            selRange() {\n              const [selStart, selEnd] = detail.selRange;\n              if (selStart >= 0 && selEnd < event.target.value.length) {\n                event.target.setSelectionRange(selStart, selEnd);\n              }\n            },\n            strokeColor() {\n              const color = detail.strokeColor;\n              event.target.style.color = ColorConverters[`${color[0]}_HTML`](\n                color.slice(1)\n              );\n            },\n          };\n          Object.keys(detail)\n            .filter(name => name in actions)\n            .forEach(name => actions[name]());\n        });\n\n        if (this.data.actions) {\n          // Even if the field hasn't any actions\n          // leaving it can still trigger some actions with Calculate\n          element.addEventListener(\"keydown\", event => {\n            elementData.beforeInputValue = event.target.value;\n            // if the key is one of Escape, Enter or Tab\n            // then the data are committed\n            let commitKey = -1;\n            if (event.key === \"Escape\") {\n              commitKey = 0;\n            } else if (event.key === \"Enter\") {\n              commitKey = 2;\n            } else if (event.key === \"Tab\") {\n              commitKey = 3;\n            }\n            if (commitKey === -1) {\n              return;\n            }\n            // Save the entered value\n            elementData.userValue = event.target.value;\n            this.linkService.eventBus?.dispatch(\"dispatcheventinsandbox\", {\n              source: this,\n              detail: {\n                id,\n                name: \"Keystroke\",\n                value: event.target.value,\n                willCommit: true,\n                commitKey,\n                selStart: event.target.selectionStart,\n                selEnd: event.target.selectionEnd,\n              },\n            });\n          });\n          const _blurListener = blurListener;\n          blurListener = null;\n          element.addEventListener(\"blur\", event => {\n            if (this._mouseState.isDown) {\n              // Focus out using the mouse: data are committed\n              elementData.userValue = event.target.value;\n              this.linkService.eventBus?.dispatch(\"dispatcheventinsandbox\", {\n                source: this,\n                detail: {\n                  id,\n                  name: \"Keystroke\",\n                  value: event.target.value,\n                  willCommit: true,\n                  commitKey: 1,\n                  selStart: event.target.selectionStart,\n                  selEnd: event.target.selectionEnd,\n                },\n              });\n            }\n            _blurListener(event);\n          });\n          element.addEventListener(\"mousedown\", event => {\n            elementData.beforeInputValue = event.target.value;\n            elementData.beforeInputSelectionRange = null;\n          });\n          element.addEventListener(\"keyup\", event => {\n            // keyup is triggered after input\n            if (event.target.selectionStart === event.target.selectionEnd) {\n              elementData.beforeInputSelectionRange = null;\n            }\n          });\n          element.addEventListener(\"select\", event => {\n            elementData.beforeInputSelectionRange = [\n              event.target.selectionStart,\n              event.target.selectionEnd,\n            ];\n          });\n\n          if (\"Keystroke\" in this.data.actions) {\n            // We should use beforeinput but this\n            // event isn't available in Firefox\n            element.addEventListener(\"input\", event => {\n              let selStart = -1;\n              let selEnd = -1;\n              if (elementData.beforeInputSelectionRange) {\n                [selStart, selEnd] = elementData.beforeInputSelectionRange;\n              }\n              this.linkService.eventBus?.dispatch(\"dispatcheventinsandbox\", {\n                source: this,\n                detail: {\n                  id,\n                  name: \"Keystroke\",\n                  value: elementData.beforeInputValue,\n                  change: event.data,\n                  willCommit: false,\n                  selStart,\n                  selEnd,\n                },\n              });\n            });\n          }\n\n          this._setEventListeners(\n            element,\n            [\n              [\"focus\", \"Focus\"],\n              [\"blur\", \"Blur\"],\n              [\"mousedown\", \"Mouse Down\"],\n              [\"mouseenter\", \"Mouse Enter\"],\n              [\"mouseleave\", \"Mouse Exit\"],\n              [\"mouseup\", \"Mouse Up\"],\n            ],\n            event => event.target.value\n          );\n        }\n      }\n\n      if (blurListener) {\n        element.addEventListener(\"blur\", blurListener);\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\n    this._setTextStyle(element);\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   * @memberof TextWidgetAnnotationElement\n   */\n  _setTextStyle(element) {\n    const TEXT_ALIGNMENT = [\"left\", \"center\", \"right\"];\n    const { fontSize, fontColor } = this.data.defaultAppearanceData;\n    const style = element.style;\n\n    // TODO: If the font-size is zero, calculate it based on the height and\n    //       width of the element.\n    // Not setting `style.fontSize` will use the default font-size for now.\n    if (fontSize) {\n      style.fontSize = `${fontSize}px`;\n    }\n\n    style.color = Util.makeHexColor(fontColor[0], fontColor[1], fontColor[2]);\n\n    if (this.data.textAlignment !== null) {\n      style.textAlign = TEXT_ALIGNMENT[this.data.textAlignment];\n    }\n  }\n}\n\nclass CheckboxWidgetAnnotationElement extends WidgetAnnotationElement {\n  constructor(parameters) {\n    super(parameters, { isRenderable: parameters.renderInteractiveForms });\n  }\n\n  render() {\n    const storage = this.annotationStorage;\n    const data = this.data;\n    const id = data.id;\n    const value = storage.getOrCreateValue(id, {\n      value: data.fieldValue && data.fieldValue !== \"Off\",\n    }).value;\n\n    this.container.className = \"buttonWidgetAnnotation checkBox\";\n\n    const element = document.createElement(\"input\");\n    element.disabled = data.readOnly;\n    element.type = \"checkbox\";\n    element.name = this.data.fieldName;\n    if (value) {\n      element.setAttribute(\"checked\", true);\n    }\n    element.setAttribute(\"id\", id);\n\n    element.addEventListener(\"change\", function (event) {\n      const name = event.target.name;\n      for (const checkbox of document.getElementsByName(name)) {\n        if (checkbox !== event.target) {\n          checkbox.checked = false;\n          storage.setValue(\n            checkbox.parentNode.getAttribute(\"data-annotation-id\"),\n            { value: false }\n          );\n        }\n      }\n      storage.setValue(id, { value: event.target.checked });\n    });\n\n    if (this.enableScripting && this.hasJSActions) {\n      element.addEventListener(\"updatefromsandbox\", event => {\n        const { detail } = event;\n        const actions = {\n          value() {\n            event.target.checked = detail.value !== \"Off\";\n            storage.setValue(id, { value: event.target.checked });\n          },\n          focus() {\n            setTimeout(() => event.target.focus({ preventScroll: false }), 0);\n          },\n          hidden() {\n            event.target.style.visibility = detail.hidden\n              ? \"hidden\"\n              : \"visible\";\n            storage.setValue(id, { hidden: detail.hidden });\n          },\n          editable() {\n            event.target.disabled = !detail.editable;\n          },\n        };\n        Object.keys(detail)\n          .filter(name => name in actions)\n          .forEach(name => actions[name]());\n      });\n\n      this._setEventListeners(\n        element,\n        [\n          [\"change\", \"Validate\"],\n          [\"change\", \"Action\"],\n          [\"focus\", \"Focus\"],\n          [\"blur\", \"Blur\"],\n          [\"mousedown\", \"Mouse Down\"],\n          [\"mouseenter\", \"Mouse Enter\"],\n          [\"mouseleave\", \"Mouse Exit\"],\n          [\"mouseup\", \"Mouse Up\"],\n        ],\n        event => event.target.checked\n      );\n    }\n\n    this.container.appendChild(element);\n    return this.container;\n  }\n}\n\nclass RadioButtonWidgetAnnotationElement extends WidgetAnnotationElement {\n  constructor(parameters) {\n    super(parameters, { isRenderable: parameters.renderInteractiveForms });\n  }\n\n  render() {\n    this.container.className = \"buttonWidgetAnnotation radioButton\";\n    const storage = this.annotationStorage;\n    const data = this.data;\n    const id = data.id;\n    const value = storage.getOrCreateValue(id, {\n      value: data.fieldValue === data.buttonValue,\n    }).value;\n\n    const element = document.createElement(\"input\");\n    element.disabled = data.readOnly;\n    element.type = \"radio\";\n    element.name = data.fieldName;\n    if (value) {\n      element.setAttribute(\"checked\", true);\n    }\n    element.setAttribute(\"pdfButtonValue\", data.buttonValue);\n    element.setAttribute(\"id\", id);\n\n    element.addEventListener(\"change\", function (event) {\n      const { target } = event;\n      for (const radio of document.getElementsByName(target.name)) {\n        if (radio !== target) {\n          storage.setValue(radio.getAttribute(\"id\"), { value: false });\n        }\n      }\n      storage.setValue(id, { value: target.checked });\n    });\n\n    if (this.enableScripting && this.hasJSActions) {\n      element.addEventListener(\"updatefromsandbox\", event => {\n        const { detail } = event;\n        const actions = {\n          value() {\n            const fieldValue = detail.value;\n            for (const radio of document.getElementsByName(event.target.name)) {\n              const radioId = radio.getAttribute(\"id\");\n              if (fieldValue === radio.getAttribute(\"pdfButtonValue\")) {\n                radio.setAttribute(\"checked\", true);\n                storage.setValue(radioId, { value: true });\n              } else {\n                storage.setValue(radioId, { value: false });\n              }\n            }\n          },\n          focus() {\n            setTimeout(() => event.target.focus({ preventScroll: false }), 0);\n          },\n          hidden() {\n            event.target.style.visibility = detail.hidden\n              ? \"hidden\"\n              : \"visible\";\n            storage.setValue(id, { hidden: detail.hidden });\n          },\n          editable() {\n            event.target.disabled = !detail.editable;\n          },\n        };\n        Object.keys(detail)\n          .filter(name => name in actions)\n          .forEach(name => actions[name]());\n      });\n\n      this._setEventListeners(\n        element,\n        [\n          [\"change\", \"Validate\"],\n          [\"change\", \"Action\"],\n          [\"focus\", \"Focus\"],\n          [\"blur\", \"Blur\"],\n          [\"mousedown\", \"Mouse Down\"],\n          [\"mouseenter\", \"Mouse Enter\"],\n          [\"mouseleave\", \"Mouse Exit\"],\n          [\"mouseup\", \"Mouse Up\"],\n        ],\n        event => event.target.checked\n      );\n    }\n\n    this.container.appendChild(element);\n    return this.container;\n  }\n}\n\nclass PushButtonWidgetAnnotationElement extends LinkAnnotationElement {\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\n    if (this.data.alternativeText) {\n      container.title = this.data.alternativeText;\n    }\n\n    return container;\n  }\n}\n\nclass ChoiceWidgetAnnotationElement extends WidgetAnnotationElement {\n  constructor(parameters) {\n    super(parameters, { isRenderable: parameters.renderInteractiveForms });\n  }\n\n  render() {\n    this.container.className = \"choiceWidgetAnnotation\";\n    const storage = this.annotationStorage;\n    const id = this.data.id;\n\n    // For printing/saving we currently only support choice widgets with one\n    // option selection. Therefore, listboxes (#12189) and comboboxes (#12224)\n    // are not properly printed/saved yet, so we only store the first item in\n    // the field value array instead of the entire array. Once support for those\n    // two field types is implemented, we should use the same pattern as the\n    // other interactive widgets where the return value of `getOrCreateValue` is\n    // used and the full array of field values is stored.\n    storage.getOrCreateValue(id, {\n      value:\n        this.data.fieldValue.length > 0 ? this.data.fieldValue[0] : undefined,\n    });\n\n    const selectElement = document.createElement(\"select\");\n    selectElement.disabled = this.data.readOnly;\n    selectElement.name = this.data.fieldName;\n    selectElement.setAttribute(\"id\", id);\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.exportValue)) {\n        optionElement.setAttribute(\"selected\", true);\n      }\n      selectElement.appendChild(optionElement);\n    }\n\n    function getValue(event) {\n      const options = event.target.options;\n      return options[options.selectedIndex].value;\n    }\n\n    if (this.enableScripting && this.hasJSActions) {\n      selectElement.addEventListener(\"updatefromsandbox\", event => {\n        const { detail } = event;\n        const actions = {\n          value() {\n            const options = event.target.options;\n            const value = detail.value;\n            const i = options.indexOf(value);\n            if (i !== -1) {\n              options.selectedIndex = i;\n              storage.setValue(id, { value });\n            }\n          },\n          focus() {\n            setTimeout(() => event.target.focus({ preventScroll: false }), 0);\n          },\n          hidden() {\n            event.target.style.visibility = detail.hidden\n              ? \"hidden\"\n              : \"visible\";\n            storage.setValue(id, { hidden: detail.hidden });\n          },\n          editable() {\n            event.target.disabled = !detail.editable;\n          },\n        };\n        Object.keys(detail)\n          .filter(name => name in actions)\n          .forEach(name => actions[name]());\n      });\n\n      selectElement.addEventListener(\"input\", event => {\n        const value = getValue(event);\n        storage.setValue(id, { value });\n\n        this.linkService.eventBus?.dispatch(\"dispatcheventinsandbox\", {\n          source: this,\n          detail: {\n            id,\n            name: \"Keystroke\",\n            changeEx: value,\n            willCommit: true,\n            commitKey: 1,\n            keyDown: false,\n          },\n        });\n      });\n\n      this._setEventListeners(\n        selectElement,\n        [\n          [\"focus\", \"Focus\"],\n          [\"blur\", \"Blur\"],\n          [\"mousedown\", \"Mouse Down\"],\n          [\"mouseenter\", \"Mouse Enter\"],\n          [\"mouseleave\", \"Mouse Exit\"],\n          [\"mouseup\", \"Mouse Up\"],\n        ],\n        event => event.target.checked\n      );\n    } else {\n      selectElement.addEventListener(\"input\", function (event) {\n        storage.setValue(id, { value: getValue(event) });\n      });\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  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 parentElements = this.layer.querySelectorAll(selector);\n    if (parentElements.length === 0) {\n      return this.container;\n    }\n\n    const popup = new PopupElement({\n      container: this.container,\n      trigger: Array.from(parentElements),\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 page = this.page;\n    const rect = Util.normalizeRect([\n      this.data.parentRect[0],\n      page.view[3] - this.data.parentRect[1] + page.view[1],\n      this.data.parentRect[2],\n      page.view[3] - this.data.parentRect[3] + page.view[1],\n    ]);\n    const popupLeft =\n      rect[0] + this.data.parentRect[2] - this.data.parentRect[0];\n    const popupTop = rect[1];\n\n    this.container.style.transformOrigin = `${-popupLeft}px ${-popupTop}px`;\n    this.container.style.left = `${popupLeft}px`;\n    this.container.style.top = `${popupTop}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  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.makeHexColor(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    if (!Array.isArray(this.trigger)) {\n      this.trigger = [this.trigger];\n    }\n\n    // Attach the event listeners to the trigger element.\n    this.trigger.forEach(element => {\n      element.addEventListener(\"click\", this._toggle.bind(this));\n      element.addEventListener(\"mouseover\", this._show.bind(this, false));\n      element.addEventListener(\"mouseout\", this._hide.bind(this, false));\n    });\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  render() {\n    this.container.className = \"freeTextAnnotation\";\n\n    if (!this.data.hasPopup) {\n      this._createPopup(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  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(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  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(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  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(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  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(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  render() {\n    this.container.className = \"caretAnnotation\";\n\n    if (!this.data.hasPopup) {\n      this._createPopup(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  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(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, {\n      isRenderable,\n      ignoreBorder: true,\n      createQuadrilaterals: true,\n    });\n  }\n\n  render() {\n    if (!this.data.hasPopup) {\n      this._createPopup(null, this.data);\n    }\n\n    if (this.quadrilaterals) {\n      return this._renderQuadrilaterals(\"highlightAnnotation\");\n    }\n\n    this.container.className = \"highlightAnnotation\";\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, {\n      isRenderable,\n      ignoreBorder: true,\n      createQuadrilaterals: true,\n    });\n  }\n\n  render() {\n    if (!this.data.hasPopup) {\n      this._createPopup(null, this.data);\n    }\n\n    if (this.quadrilaterals) {\n      return this._renderQuadrilaterals(\"underlineAnnotation\");\n    }\n\n    this.container.className = \"underlineAnnotation\";\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, {\n      isRenderable,\n      ignoreBorder: true,\n      createQuadrilaterals: true,\n    });\n  }\n\n  render() {\n    if (!this.data.hasPopup) {\n      this._createPopup(null, this.data);\n    }\n\n    if (this.quadrilaterals) {\n      return this._renderQuadrilaterals(\"squigglyAnnotation\");\n    }\n\n    this.container.className = \"squigglyAnnotation\";\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, {\n      isRenderable,\n      ignoreBorder: true,\n      createQuadrilaterals: true,\n    });\n  }\n\n  render() {\n    if (!this.data.hasPopup) {\n      this._createPopup(null, this.data);\n    }\n\n    if (this.quadrilaterals) {\n      return this._renderQuadrilaterals(\"strikeoutAnnotation\");\n    }\n\n    this.container.className = \"strikeoutAnnotation\";\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  render() {\n    this.container.className = \"stampAnnotation\";\n\n    if (!this.data.hasPopup) {\n      this._createPopup(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    this.linkService.eventBus?.dispatch(\"fileattachmentannotation\", {\n      source: this,\n      id: stringToPDFString(filename),\n      filename,\n      content,\n    });\n  }\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(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 * @property {boolean} [enableScripting] - Enable embedded script execution.\n * @property {boolean} [hasJSActions] - Some fields have JS actions.\n *   The default value is `false`.\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:\n          typeof parameters.renderInteractiveForms === \"boolean\"\n            ? parameters.renderInteractiveForms\n            : true,\n        svgFactory: new DOMSVGFactory(),\n        annotationStorage:\n          parameters.annotationStorage || new AnnotationStorage(),\n        enableScripting: parameters.enableScripting,\n        hasJSActions: parameters.hasJSActions,\n        mouseState: parameters.mouseState || { isDown: false },\n      });\n      if (element.isRenderable) {\n        const rendered = element.render();\n        if (data.hidden) {\n          rendered.style.visibility = \"hidden\";\n        }\n        if (Array.isArray(rendered)) {\n          for (const renderedElement of rendered) {\n            parameters.div.appendChild(renderedElement);\n          }\n        } else {\n          if (element instanceof PopupAnnotationElement) {\n            // Popup annotation elements should not be on top of other\n            // annotation elements to prevent interfering with mouse events.\n            parameters.div.prepend(rendered);\n          } else {\n            parameters.div.appendChild(rendered);\n          }\n        }\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    const transform = `matrix(${parameters.viewport.transform.join(\",\")})`;\n    for (const data of parameters.annotations) {\n      const elements = parameters.div.querySelectorAll(\n        `[data-annotation-id=\"${data.id}\"]`\n      );\n      if (elements) {\n        elements.forEach(element => {\n          element.style.transform = transform;\n        });\n      }\n    }\n    parameters.div.removeAttribute(\"hidden\");\n  }\n}\n\nexport { AnnotationLayer };\n","/* Copyright 2020 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/**\n * PLEASE NOTE: This file is currently imported in both the `../display/` and\n *              `../scripting_api/` folders, hence be EXTREMELY careful about\n *              introducing any dependencies here since that can lead to an\n *              unexpected/unnecessary size increase of the *built* files.\n */\n\nfunction makeColorComp(n) {\n  return Math.floor(Math.max(0, Math.min(1, n)) * 255)\n    .toString(16)\n    .padStart(2, \"0\");\n}\n\n// PDF specifications section 10.3\nclass ColorConverters {\n  static CMYK_G([c, y, m, k]) {\n    return [\"G\", 1 - Math.min(1, 0.3 * c + 0.59 * m + 0.11 * y + k)];\n  }\n\n  static G_CMYK([g]) {\n    return [\"CMYK\", 0, 0, 0, 1 - g];\n  }\n\n  static G_RGB([g]) {\n    return [\"RGB\", g, g, g];\n  }\n\n  static G_HTML([g]) {\n    const G = makeColorComp(g);\n    return `#${G}${G}${G}`;\n  }\n\n  static RGB_G([r, g, b]) {\n    return [\"G\", 0.3 * r + 0.59 * g + 0.11 * b];\n  }\n\n  static RGB_HTML([r, g, b]) {\n    const R = makeColorComp(r);\n    const G = makeColorComp(g);\n    const B = makeColorComp(b);\n    return `#${R}${G}${B}`;\n  }\n\n  static T_HTML() {\n    return \"#00000000\";\n  }\n\n  static CMYK_RGB([c, y, m, k]) {\n    return [\n      \"RGB\",\n      1 - Math.min(1, c + k),\n      1 - Math.min(1, m + k),\n      1 - Math.min(1, y + k),\n    ];\n  }\n\n  static CMYK_HTML(components) {\n    return this.RGB_HTML(this.CMYK_RGB(components));\n  }\n\n  static RGB_CMYK([r, g, b]) {\n    const c = 1 - r;\n    const m = 1 - g;\n    const y = 1 - b;\n    const k = Math.min(c, m, y);\n    return [\"CMYK\", c, m, y, k];\n  }\n}\n\nexport { ColorConverters };\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 {import(\"./api\").TextContent} [textContent] - Text content to\n *   render (the object 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 {import(\"./display_utils\").PageViewport} viewport - The target\n *   viewport to properly layout the text runs.\n * @property {Array<HTMLElement>} [textDivs] - HTML elements that are correspond\n *   to the text items of the textContent input. This is output and shall be\n *   initially be set to empty array.\n * @property {Array<string>} [textContentItemsStr] - Strings that correspond to\n *    the `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 */\n\n/**\n * @typedef {Object} TextLayerRenderTask\n * @property {Promise<void>} promise\n * @property {() => void} cancel\n * @property {(expandDivs: boolean) => void} expandTextDivs\n */\n\n/**\n * @type {(renderParameters: TextLayerRenderParameters) => TextLayerRenderTask}\n */\nconst renderTextLayer = (function renderTextLayerClosure() {\n  const MAX_TEXT_DIVS_TO_RENDER = 100000;\n\n  const 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    const textDiv = document.createElement(\"span\");\n    const 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    const tx = Util.transform(task._viewport.transform, geom.transform);\n    let angle = Math.atan2(tx[1], tx[0]);\n    const style = styles[geom.fontName];\n    if (style.vertical) {\n      angle += Math.PI / 2;\n    }\n    const fontHeight = Math.sqrt(tx[2] * tx[2] + tx[3] * tx[3]);\n    let 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      let angleCos = 1,\n        angleSin = 0;\n      if (angle !== 0) {\n        angleCos = Math.cos(angle);\n        angleSin = Math.sin(angle);\n      }\n      const divWidth =\n        (style.vertical ? geom.height : geom.width) * task._viewport.scale;\n      const divHeight = fontHeight;\n\n      let 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    const textDivs = task._textDivs;\n    const capability = task._capability;\n    const 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 (let 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    const bounds = task._bounds;\n    const viewport = task._viewport;\n\n    const expanded = expandBounds(viewport.width, viewport.height, bounds);\n    for (let i = 0; i < expanded.length; i++) {\n      const div = bounds[i].div;\n      const 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      const e = expanded[i],\n        b = bounds[i];\n      const m = b.m,\n        c = m[0],\n        s = m[1];\n      // Finding intersections with expanded box.\n      const points = [[0, 0], [0, b.size[1]], [b.size[0], 0], b.size];\n      const ts = new Float64Array(64);\n      points.forEach(function (p, j) {\n        const 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      const 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    const 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    const expanded = new Array(boxes.length);\n    bounds.forEach(function (b) {\n      const 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      const 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      const 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    const fakeBoundary = {\n      x1: -Infinity,\n      y1: -Infinity,\n      x2: 0,\n      y2: Infinity,\n      index: -1,\n      x1New: 0,\n      x2New: 0,\n    };\n    const 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      let i = 0;\n      while (i < horizon.length && horizon[i].end <= boundary.y1) {\n        i++;\n      }\n      let j = horizon.length - 1;\n      while (j >= 0 && horizon[j].start >= boundary.y2) {\n        j--;\n      }\n\n      let horizonPart, affectedBoundary;\n      let q,\n        k,\n        maxXNew = -Infinity;\n      for (q = i; q <= j; q++) {\n        horizonPart = horizon[q];\n        affectedBoundary = horizonPart.boundary;\n        let 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      const changedHorizon = [];\n      let 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        const 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        let 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      const 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._document = container.ownerDocument;\n    this._viewport = viewport;\n    this._textDivs = textDivs || [];\n    this._textContentItemsStr = textContentItemsStr || [];\n    this._enhanceTextSelection = !!enhanceTextSelection;\n    this._fontInspectorEnabled = !!globalThis.FontInspector?.enabled;\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 = this._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 (let 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  // eslint-disable-next-line no-shadow\n  function renderTextLayer(renderParameters) {\n    const 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\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\n/** @type {any} */\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      current.fontMatrix = fontObj.fontMatrix || 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?.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.makeHexColor(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.makeHexColor(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.makeHexColor(...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 = objId.startsWith(\"g_\")\n        ? this.commonObjs.get(objId)\n        : 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?._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\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  getRequestXhr(xhrId) {\n    return this.pendingRequests[xhrId].xhr;\n  }\n\n  isPendingRequest(xhrId) {\n    return xhrId in this.pendingRequests;\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\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?.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?._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    )\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      .catch(reason => {\n        if (reason?.name === \"AbortError\") {\n          return;\n        }\n        throw reason;\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","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __w_pdfjs_require__(moduleId) {\n\t// Check if module is in cache\n\tif(__webpack_module_cache__[moduleId]) {\n\t\treturn __webpack_module_cache__[moduleId].exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId](module, module.exports, __w_pdfjs_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// module exports must be returned from runtime so entry inlining is disabled\n// startup\n// Load entry module and return exports\nreturn __w_pdfjs_require__(0);\n"],"sourceRoot":""}