Delete unused PDF-related code (#6334)

* Remove new logs UI code
* Remove unused preview components
* Move metrics file
* Remove Angular PDF controllers
* Move the service worker util functions
* Remove the ide/pdfng folder
* Remove vendored pdf.js
* Remove showNewPdfPreview
* Use mockCompile
* Remove split test code

GitOrigin-RevId: 723b7440c62cda51f6ad8bb9c691900882166d21

services/web/.storybook/preview.js

@@ -128,4 +128,3 @@ window.user = {
 }
 
 window.project_id = 'storybook-project'
-window.showNewPdfPreview = true

services/web/app/src/Features/Project/ProjectController.js

@@ -784,21 +784,6 @@ const ProjectController = {
             }
           )
         },
-        newPdfPreviewAssignment(cb) {
-          SplitTestHandler.getAssignment(
-            req,
-            'react-pdf-preview-rollout',
-            {},
-            (error, assignment) => {
-              if (error) {
-                // do not fail editor load if assignment fails
-                cb(null, { variant: 'default' })
-              } else {
-                cb(null, assignment)
-              }
-            }
-          )
-        },
         newSourceEditorAssignment(cb) {
           SplitTestHandler.getAssignment(
             req,
@@ -829,21 +814,6 @@ const ProjectController = {
             }
           )
         },
-        logsUIAssignment(cb) {
-          SplitTestHandler.getAssignment(
-            req,
-            'logs-ui',
-            {},
-            (error, assignment) => {
-              // do not fail editor load if assignment fails
-              if (error) {
-                cb(null, { variant: 'default' })
-              } else {
-                cb(null, assignment)
-              }
-            }
-          )
-        },
       },
       (
         err,
@@ -854,10 +824,8 @@ const ProjectController = {
           subscription,
           isTokenMember,
           brandVariation,
-          newPdfPreviewAssignment,
           newSourceEditorAssignment,
           pdfDetachAssignment,
-          logsUIAssignment,
         }
       ) => {
         if (err != null) {
@@ -941,11 +909,6 @@ const ProjectController = {
               return shouldDisplayFeature('enable_pdf_caching', false)
             }
 
-            let showNewPdfPreview = shouldDisplayFeature(
-              'new_pdf_preview',
-              newPdfPreviewAssignment.variant === 'react-pdf-preview'
-            )
-
             const showPdfDetach = shouldDisplayFeature(
               'pdf_detach',
               pdfDetachAssignment.variant === 'enabled'
@@ -956,7 +919,6 @@ const ProjectController = {
             let detachRole = null
 
             if (showPdfDetach) {
-              showNewPdfPreview = true
               detachRole = req.params.detachRole
             }
 
@@ -1023,10 +985,8 @@ const ProjectController = {
               gitBridgePublicBaseUrl: Settings.gitBridgePublicBaseUrl,
               wsUrl,
               showSupport: Features.hasFeature('support'),
-              logsUIVariant: logsUIAssignment.variant,
               showPdfDetach,
               debugPdfDetach,
-              showNewPdfPreview,
               showNewSourceEditorOption,
               showSymbolPalette,
               trackPdfDownload: partOfPdfCachingRollout('collect-metrics'),

services/web/app/views/project/editor.pug

@@ -67,10 +67,7 @@ block content
 
 		if detachRole === 'detached'
 			div.full-size
-				if showNewPdfPreview
-					pdf-preview()
-				else
-					include ./editor/pdf
+				pdf-preview()
 		else
 			include ./editor/main
 

services/web/app/views/project/editor/editor.pug

@@ -16,48 +16,18 @@ div.full-size(
 
 	.ui-layout-east
 		div(ng-if="ui.pdfLayout == 'sideBySide'")
-			if showNewPdfPreview
-				pdf-preview()
-			else
-				include ./pdf
+			pdf-preview()
 
-	if showNewPdfPreview
-		.ui-layout-resizer-controls.synctex-controls(
-			ng-show="settings.pdfViewer !== 'native'"
-		)
-			pdf-synctex-controls()
-	else
-		.ui-layout-resizer-controls.synctex-controls(
-			ng-show="!!pdf.url && settings.pdfViewer !== 'native'"
-			ng-controller="PdfSynctexController"
-		)
-			a.btn.btn-default.btn-xs.synctex-control.synctex-control-goto-pdf(
-				tooltip=translate('go_to_code_location_in_pdf')
-				tooltip-placement="right"
-				tooltip-append-to-body="true"
-				ng-click="syncToPdf()"
-				ng-disabled="syncToPdfInFlight"
-			)
-				i.synctex-control-icon(ng-show="!syncToPdfInFlight")
-				i.synctex-spin-icon.fa.fa-refresh.fa-spin(ng-show="syncToPdfInFlight")
-			a.btn.btn-default.btn-xs.synctex-control.synctex-control-goto-code(
-				tooltip=translate('go_to_pdf_location_in_code')
-				tooltip-placement="right"
-				tooltip-append-to-body="true"
-				ng-click="syncToCode()"
-				ng-disabled="syncToCodeInFlight"
-			)
-				i.synctex-control-icon(ng-show="!syncToCodeInFlight")
-				i.synctex-spin-icon.fa.fa-refresh.fa-spin(ng-show="syncToCodeInFlight")
+	.ui-layout-resizer-controls.synctex-controls(
+		ng-show="settings.pdfViewer !== 'native'"
+	)
+		pdf-synctex-controls()
 
 div.full-size(
 	ng-if="ui.pdfLayout == 'flat'"
 	ng-show="ui.view == 'pdf'"
 )
-	if showNewPdfPreview
-		pdf-preview()
-	else
-		include ./pdf
+	pdf-preview()
 
 // fallback, shown when no file/view is selected
 div.full-size.no-file-selection(

services/web/app/views/project/editor/meta.pug

@@ -20,10 +20,8 @@ meta(name="ol-pdfImageResourcesPath" content="/images/")
 //- used in public/js/libs/sharejs.js
 meta(name="ol-useShareJsHash" data-type="boolean" content=true)
 meta(name="ol-wsRetryHandshake" data-type="json" content=settings.wsRetryHandshake)
-meta(name="ol-logsUIVariant" content=logsUIVariant)
 meta(name="ol-showPdfDetach" data-type="boolean" content=showPdfDetach)
 meta(name="ol-debugPdfDetach" data-type="boolean" content=debugPdfDetach)
-meta(name="ol-showNewPdfPreview" data-type="boolean" content=showNewPdfPreview)
 meta(name="ol-showNewSourceEditorOption" data-type="boolean" content=showNewSourceEditorOption)
 meta(name="ol-showSymbolPalette" data-type="boolean" content=showSymbolPalette)
 meta(name="ol-enablePdfCaching" data-type="boolean" content=enablePdfCaching)

services/web/app/views/project/editor/pdf.pug

@@ -1,430 +0,0 @@
-div.full-size.pdf(ng-controller="PdfController")
-	if ['new-logs-ui-with-popup', 'new-logs-ui-without-popup'].includes(logsUIVariant)
-		preview-pane(
-			compiler-state=`{
-				autoCompileHasChanges: changesToAutoCompile,
-				autoCompileHasLintingError: autoCompileLintingError,
-				isAutoCompileOn: autocompile_enabled,
-				isClearingCache: pdf.clearingCache,
-				isCompiling: pdf.compiling,
-				isDraftModeOn: draft,
-				isSyntaxCheckOn: stop_on_validation_error,
-				lastCompileTimestamp: pdf.lastCompileTimestamp,
-				logEntries: pdf.logEntries,
-				validationIssues: pdf.validation,
-				rawLog: pdf.rawLog,
-				compileFailed: pdf.compileFailed,
-				errors: {
-					error: pdf.error,
-					renderingError: pdf.renderingError,
-					clsiMaintenance: pdf.clsiMaintenance,
-					clsiUnavailable: pdf.clsiUnavailable,
-					tooRecentlyCompiled: pdf.tooRecentlyCompiled,
-					compileTerminated: pdf.compileTerminated,
-					rateLimited: pdf.rateLimited,
-					compileInProgress: pdf.compileInProgress,
-					timedout: pdf.timedout,
-					projectTooLarge: pdf.projectTooLarge,
-					autoCompileDisabled: pdf.autoCompileDisabled,
-					failure: pdf.failure
-				}
-			}`
-			on-clear-cache="clearCache"
-			on-recompile="recompile"
-			on-recompile-from-scratch="recompileFromScratch"
-			on-run-syntax-check-now="runSyntaxCheckNow"
-			on-set-auto-compile="setAutoCompile"
-			on-set-draft-mode="setDraftMode"
-			on-set-syntax-check="setSyntaxCheck"
-			on-toggle-logs="toggleLogs"
-			output-files="pdf.outputFiles"
-			pdf-download-url="pdf.downloadUrl"
-			split-layout="ui.pdfLayout === 'sideBySide'"
-			on-set-split-layout="setPdfSplitLayout"
-			on-set-full-layout="setPdfFullLayout"
-			on-stop-compilation="stop"
-			variant-with-first-error-popup="logsUIVariant === 'new-logs-ui-with-popup'"
-			show-logs="shouldShowLogs"
-			on-log-entry-location-click="openInEditor"
-		)
-	else
-		.toolbar.toolbar-pdf(ng-class="{ 'changes-to-autocompile': changesToAutoCompile && !autoCompileLintingError }")
-			.btn-group.btn-recompile-group#recompile(
-				dropdown,
-				tooltip-html="'"+translate('recompile_pdf')+" <span class=\"keyboard-shortcut\">({{modifierKey}} + Enter)</span>'"
-				tooltip-class="keyboard-tooltip"
-				tooltip-popup-delay="500"
-				tooltip-append-to-body="true"
-				tooltip-placement="bottom"
-			)
-				a.btn.btn-recompile(
-					href,
-					ng-disabled="pdf.compiling",
-					ng-click="recompile()"
-				)
-					i.fa.fa-refresh(
-						ng-class="{'fa-spin': pdf.compiling }"
-					)
-					span.btn-recompile-label(ng-show="!pdf.compiling") #{translate("recompile")}
-					span.btn-recompile-label(ng-show="pdf.compiling") #{translate("compiling")}…
-					
-				a.btn.btn-recompile.dropdown-toggle(
-					href,
-					ng-disabled="pdf.compiling",
-					dropdown-toggle
-				)
-					span.caret
-				ul.dropdown-menu.dropdown-menu-left
-					li.dropdown-header #{translate("auto_compile")}
-					li
-						a(href, ng-click="autocompile_enabled = true")
-							i.fa.fa-fw(ng-class="{'fa-check': autocompile_enabled}")
-							| &nbsp;#{translate('on')}
-					li
-						a(href, ng-click="autocompile_enabled = false")
-							i.fa.fa-fw(ng-class="{'fa-check': !autocompile_enabled}")
-							| &nbsp;#{translate('off')}
-					li.dropdown-header #{translate("compile_mode")}
-					li
-						a(href, ng-click="draft = false")
-							i.fa.fa-fw(ng-class="{'fa-check': !draft}")
-							| &nbsp;#{translate("normal")}
-					li
-						a(href, ng-click="draft = true")
-							i.fa.fa-fw(ng-class="{'fa-check': draft}")
-							| &nbsp;#{translate("fast")}&nbsp;
-							span.subdued [draft]
-					li.dropdown-header #{translate("compile_time_checks")}
-					li
-						a(href, ng-click="stop_on_validation_error = true")
-							i.fa.fa-fw(ng-class="{'fa-check': stop_on_validation_error}")
-							| &nbsp;#{translate("stop_on_validation_error")}
-					li
-						a(href, ng-click="stop_on_validation_error = false")
-							i.fa.fa-fw(ng-class="{'fa-check': !stop_on_validation_error}")
-							| &nbsp;#{translate("ignore_validation_errors")}
-					li
-						a(href, ng-click="recompile({check:true})")
-							i.fa.fa-fw()
-							| &nbsp;#{translate("run_syntax_check_now")}
-			a(
-				href
-				ng-click="stop()"
-				ng-show="pdf.compiling",
-				tooltip=translate('stop_compile')
-				tooltip-placement="bottom"
-			)
-				i.fa.fa-fw.fa-stop()
-			a.log-btn(
-				href
-				ng-click="toggleLogs()"
-				ng-class="{ 'active': shouldShowLogs == true }"
-				tooltip=translate('logs_and_output_files')
-				tooltip-placement="bottom"
-			)
-				i.fa.fa-fw.fa-file-text-o
-				span.label(
-					ng-show="pdf.logEntries.warnings.length + pdf.logEntries.errors.length > 0"
-					ng-class="{\
-						'label-warning': pdf.logEntries.errors.length == 0,\
-						'label-danger': pdf.logEntries.errors.length > 0\
-					}"
-				) {{ pdf.logEntries.errors.length + pdf.logEntries.warnings.length }}
-				
-			a(
-				ng-if="!pdf.downloadUrl"
-				disabled
-				href="#"
-				tooltip=translate('please_compile_pdf_before_download')
-				tooltip-placement="bottom"
-			)
-				i.fa.fa-fw.fa-download
-			a(
-				ng-href="{{pdf.downloadUrl || pdf.url}}"
-				target="_blank"
-				ng-if="pdf.url"
-				tooltip=translate('download_pdf')
-				tooltip-placement="bottom"
-			)
-				i.fa.fa-fw.fa-download
-				
-			.toolbar-right
-				span.auto-compile-status.small(
-					ng-show="changesToAutoCompile && !compiling && !autoCompileLintingError"
-				) #{translate('uncompiled_changes')}
-				span.auto-compile-status.auto-compile-error.small(
-					ng-show="autoCompileLintingError"
-					tooltip-placement="bottom"
-					tooltip=translate("code_check_failed_explanation")
-					tooltip-append-to-body="true"
-				)
-					i.fa.fa-fw.fa-exclamation-triangle
-					|
-					| #{translate("code_check_failed")}
-				a(
-					href,
-					ng-click="switchToFlatLayout('pdf')"
-					ng-show="ui.pdfLayout == 'sideBySide'"
-					tooltip=translate('full_screen')
-					tooltip-placement="left"
-					tooltip-append-to-body="true"
-				)
-					i.fa.fa-expand
-				a(
-					href,
-					ng-click="switchToSideBySideLayout('editor')"
-					ng-show="ui.pdfLayout == 'flat'"
-					tooltip=translate('split_screen')
-					tooltip-placement="left"
-					tooltip-append-to-body="true"
-				)
-					i.fa.fa-compress
-		// end of toolbar
-
-		// logs view
-		.pdf-logs(ng-show="shouldShowLogs")
-			.alert.alert-success(ng-show="pdf.logEntries.all.length == 0 && !pdf.failure")
-				| #{translate("no_errors_good_job")}
-
-			.alert.alert-danger(ng-show="pdf.failure")
-				strong #{translate("compile_error")}. 
-				span #{translate("generic_failed_compile_message")}.
-
-			.alert.alert-danger(ng-show="pdf.failedCheck")
-				strong #{translate("failed_compile_check")}.
-				p
-				p.text-center(ng-show="!check")
-					a.text-info(
-						href,
-						ng-disabled="pdf.compiling",
-						ng-click="recompile({try:true})"
-					) #{translate("failed_compile_check_try")}
-					| &#32;#{translate("failed_compile_option_or")}&#32;
-					a.text-info(
-						href,
-						ng-disabled="pdf.compiling",
-						ng-click="recompile({force:true})"
-					) #{translate("failed_compile_check_ignore")}
-					| .
-
-			div(ng-repeat="entry in pdf.logEntries.all")
-				.alert(
-					ng-class="{\
-						'alert-danger':  entry.level == 'error',\
-						'alert-warning': entry.level == 'warning',\
-						'alert-info':    entry.level == 'typesetting'\
-					}"
-					ng-click="openInEditor(entry)"
-				)
-					span.line-no
-						i.fa.fa-link(aria-hidden="true")
-						| &nbsp;
-						span(ng-show="entry.file") {{ entry.file }}
-						span(ng-show="entry.line") , line {{ entry.line }}
-					p.entry-message(ng-show="entry.message")
-						| {{ entry.type }} {{ entry.message }}
-					.card.card-hint(
-						ng-if="entry.humanReadableHint"
-						stop-propagation="click"
-					)
-						figure.card-hint-icon-container
-							i.fa.fa-lightbulb-o(aria-hidden="true")
-						p.card-hint-text(
-							ng-show="entry.humanReadableHint",
-							ng-bind-html="entry.humanReadableHint")
-						.card-hint-footer.clearfix
-							.card-hint-ext-link(ng-if="entry.extraInfoURL")
-								a(
-									ng-href="{{ entry.extraInfoURL }}",
-									ng-click="trackLogHintsLearnMore()"
-									target="_blank"
-								)
-									i.fa.fa-external-link
-									|&nbsp;#{translate("log_hint_extra_info")}
-
-					p.entry-content(ng-show="entry.content") {{ entry.content.trim() }}
-
-			div
-				.files-dropdown-container
-					a.btn.btn-default.btn-sm(
-						href,
-						tooltip=translate('clear_cached_files'),
-						tooltip-placement="top",
-						tooltip-append-to-body="true",
-						ng-click="openClearCacheModal()"
-					)
-						i.fa.fa-trash-o
-					| &nbsp;
-					div.files-dropdown(
-						ng-class="shouldDropUp ? 'dropup' : 'dropdown'"
-						dropdown
-					)
-						a.btn.btn-default.btn-sm(
-							href
-							dropdown-toggle
-						)
-							| #{translate("other_logs_and_files")}
-							span.caret
-						ul.dropdown-menu.dropdown-menu-right
-							li(ng-repeat="file in pdf.outputFiles")
-								a(
-									ng-href="{{file.url}}"
-									target="_blank"
-								) {{ file.name }}
-				a.btn.btn-info.btn-sm(href, ng-click="toggleRawLog()")
-					span(ng-show="!pdf.showRawLog") #{translate("view_raw_logs")}
-					span(ng-show="pdf.showRawLog") #{translate("hide_raw_logs")}
-
-			pre(ng-bind="pdf.rawLog", ng-show="pdf.showRawLog")
-	
-	
-	// non-log views (pdf and errors)
-	div(ng-show="!shouldShowLogs", ng-switch on="pdf.view")
-		.pdf-uncompiled(ng-switch-when="uncompiled" ng-show="!pdf.compiling")
-			| &nbsp;
-			i.fa.fa-level-up.fa-flip-horizontal.fa-2x
-			| &nbsp;&nbsp;#{translate('click_here_to_preview_pdf')}
-		
-		.pdf-viewer(ng-switch-when="pdf")
-			div(
-				pdfng
-				ng-if="settings.pdfViewer == 'pdfjs'"
-				pdf-src="pdf.url"
-				key="{{ project_id }}"
-				resize-on="layout:main:resize,layout:pdf:resize"
-				highlights="pdf.highlights"
-				position="pdf.position"
-				first-render-done="pdf.firstRenderDone"
-				update-consumed-bandwidth="pdf.updateConsumedBandwidth"
-				dbl-click-callback="syncToCode"
-			)
-			iframe(
-				ng-src="{{ pdf.url | trusted }}"
-				ng-if="settings.pdfViewer == 'native'"
-			)
-
-		if logsUIVariant === 'default'
-			.pdf-validation-problems(ng-switch-when="validation-problems")
-
-				.alert.alert-danger(ng-show="pdf.validation.sizeCheck")
-					strong #{translate("project_too_large")} 
-					div #{translate("project_too_large_please_reduce")}
-					div
-						li(ng-repeat="entry in pdf.validation.sizeCheck.resources") {{ '/'+entry['path'] }} - {{entry['kbSize']}}kb
-		
-				.alert.alert-danger(ng-show="pdf.validation.conflictedPaths")
-					div
-						strong #{translate("conflicting_paths_found")}
-					div !{translate("following_paths_conflict")}
-					div
-						li(ng-repeat="entry in pdf.validation.conflictedPaths") {{ '/'+entry['path'] }}
-
-				.alert.alert-danger(ng-show="pdf.validation.mainFile")
-					strong #{translate("main_file_not_found")} 
-					span #{translate("please_set_main_file")}
-
-			.pdf-errors(ng-switch-when="errors")
-		
-				.alert.alert-danger(ng-show="pdf.error")
-					strong #{translate("server_error")} 
-					span #{translate("somthing_went_wrong_compiling")}
-
-				.alert.alert-danger(ng-show="pdf.renderingError")
-					strong #{translate("pdf_rendering_error")} 
-					span #{translate("something_went_wrong_rendering_pdf")}
-		
-				.alert.alert-danger(ng-show="pdf.clsiMaintenance")
-					strong #{translate("server_error")} 
-					span #{translate("clsi_maintenance")}
-
-				.alert.alert-danger(ng-show="pdf.clsiUnavailable")
-					strong #{translate("server_error")} 
-					span #{translate("clsi_unavailable")}
-
-				.alert.alert-danger(ng-show="pdf.tooRecentlyCompiled")
-					strong #{translate("server_error")} 
-					span #{translate("too_recently_compiled")}
-
-				.alert.alert-danger(ng-show="pdf.compileTerminated")
-					strong #{translate("terminated")}. 
-					span #{translate("compile_terminated_by_user")}
-				
-				.alert.alert-danger(ng-show="pdf.rateLimited")
-					strong #{translate("pdf_compile_rate_limit_hit")} 
-					span #{translate("project_flagged_too_many_compiles")}
-
-				.alert.alert-danger(ng-show="pdf.compileInProgress")
-					strong #{translate("pdf_compile_in_progress_error")}. 
-					span #{translate("pdf_compile_try_again")}
-
-				.alert.alert-danger(ng-show="pdf.timedout")
-					p
-						strong #{translate("timedout")}. 
-						span #{translate("proj_timed_out_reason")}
-					p
-						a.text-info(href="https://www.sharelatex.com/learn/Debugging_Compilation_timeout_errors", target="_blank")
-							| #{translate("learn_how_to_make_documents_compile_quickly")}
-
-				if settings.enableSubscriptions
-					.alert.alert-success(ng-show="pdf.timedout && !hasPremiumCompile")
-						p(ng-if="project.owner._id == user.id")
-							strong #{translate("upgrade_for_longer_compiles")}
-						p(ng-if="project.owner._id != user.id")
-							strong #{translate("ask_proj_owner_to_upgrade_for_longer_compiles")}
-						p #{translate("free_accounts_have_timeout_upgrade_to_increase")}
-						p #{translate("plus_upgraded_accounts_receive")}:
-						div
-							ul.list-unstyled
-								li
-									i.fa.fa-check &nbsp;
-									| #{translate("unlimited_projects")}
-								li
-									i.fa.fa-check &nbsp;
-									| #{translate("collabs_per_proj", {collabcount:'Multiple'})}
-								li
-									i.fa.fa-check &nbsp;
-									| #{translate("full_doc_history")}
-								li
-									i.fa.fa-check &nbsp;
-									| #{translate("sync_to_dropbox")}
-								li
-									i.fa.fa-check &nbsp;
-									| #{translate("sync_to_github")}
-								li
-									i.fa.fa-check &nbsp;
-									|#{translate("compile_larger_projects")}
-						p(ng-controller="FreeTrialModalController", ng-if="project.owner._id == user.id")
-							a.btn.btn-success.row-spaced-small(
-								href
-								ng-class="buttonClass"
-								ng-click="startFreeTrial('compile-timeout')"
-							) #{translate("start_free_trial")}
-
-				.alert.alert-danger(ng-show="pdf.autoCompileDisabled")
-					p
-						strong #{translate("autocompile_disabled")}. 
-						span #{translate("autocompile_disabled_reason")}
-
-				.alert.alert-danger(ng-show="pdf.projectTooLarge")
-					strong #{translate("project_too_large")} 
-					span #{translate("project_too_much_editable_text")}
-
-
-script(type='text/ng-template', id='clearCacheModalTemplate')
-	.modal-header
-		h3 #{translate("clear_cache")}?
-	.modal-body
-		p #{translate("clear_cache_explanation")}
-		p #{translate("clear_cache_is_safe")}
-		.alert.alert-danger(ng-if="state.error") #{translate("generic_something_went_wrong")}.
-	.modal-footer
-		button.btn.btn-default(
-			ng-click="cancel()"
-			ng-disabled="state.inflight"
-		) #{translate("cancel")}
-		button.btn.btn-info(
-			ng-click="clear()"
-			ng-disabled="state.inflight"
-		) 
-			span(ng-show="!state.inflight") #{translate("clear_cache")}
-			span(ng-show="state.inflight") #{translate("clearing")}…

services/web/frontend/js/features/pdf-preview/util/compiler.js

@@ -2,7 +2,7 @@ import { isMainFile } from './editor-files'
 import getMeta from '../../../utils/meta'
 import { deleteJSON, postJSON } from '../../../infrastructure/fetch-json'
 import { debounce } from 'lodash'
-import { trackPdfDownload } from '../../../ide/pdf/controllers/PdfJsMetrics'
+import { trackPdfDownload } from './metrics'
 
 const AUTO_COMPILE_MAX_WAIT = 5000
 // We add a 2 second debounce to sending user changes to server if they aren't
@@ -59,10 +59,6 @@ export default class DocumentCompiler {
     if (!options) {
       options = {}
     }
-    // only compile if the feature flag is enabled
-    if (!window.showNewPdfPreview) {
-      return
-    }
 
     // set "compiling" to true (in the React component's state), and return if it was already true
     const wasCompiling = this.compilingRef.current

services/web/frontend/js/features/preview/components/preview-download-button.js

@@ -1,83 +0,0 @@
-import PropTypes from 'prop-types'
-import { Dropdown, OverlayTrigger, Tooltip } from 'react-bootstrap'
-import { useTranslation } from 'react-i18next'
-import PreviewDownloadFileList from './preview-download-file-list'
-import Icon from '../../../shared/components/icon'
-import ControlledDropdown from '../../../shared/components/controlled-dropdown'
-
-function PreviewDownloadButton({
-  isCompiling,
-  outputFiles,
-  pdfDownloadUrl,
-  showText,
-}) {
-  const { t } = useTranslation()
-
-  let textStyle = {}
-  if (!showText) {
-    textStyle = {
-      position: 'absolute',
-      right: '-100vw',
-    }
-  }
-
-  const pdfDownloadDisabled = isCompiling || !pdfDownloadUrl
-  const buttonElement = (
-    <a
-      className="btn btn-xs btn-info"
-      disabled={pdfDownloadDisabled}
-      download
-      href={pdfDownloadUrl || '#'}
-      style={{ pointerEvents: 'auto' }}
-    >
-      <Icon type="download" fw />
-      <span className="toolbar-text" style={textStyle}>
-        {t('download_pdf')}
-      </span>
-    </a>
-  )
-
-  const hideTooltip = showText && pdfDownloadUrl
-
-  return (
-    <ControlledDropdown
-      id="download-dropdown"
-      className="toolbar-item"
-      disabled={isCompiling}
-    >
-      {hideTooltip ? (
-        buttonElement
-      ) : (
-        <OverlayTrigger
-          placement="bottom"
-          overlay={
-            <Tooltip id="tooltip-download-pdf">
-              {pdfDownloadDisabled
-                ? t('please_compile_pdf_before_download')
-                : t('download_pdf')}
-            </Tooltip>
-          }
-        >
-          {buttonElement}
-        </OverlayTrigger>
-      )}
-      <Dropdown.Toggle
-        className="btn btn-xs btn-info dropdown-toggle"
-        aria-label={t('toggle_output_files_list')}
-        bsStyle="info"
-      />
-      <Dropdown.Menu id="download-dropdown-list">
-        <PreviewDownloadFileList fileList={outputFiles} />
-      </Dropdown.Menu>
-    </ControlledDropdown>
-  )
-}
-
-PreviewDownloadButton.propTypes = {
-  isCompiling: PropTypes.bool.isRequired,
-  outputFiles: PropTypes.array,
-  pdfDownloadUrl: PropTypes.string,
-  showText: PropTypes.bool.isRequired,
-}
-
-export default PreviewDownloadButton

services/web/frontend/js/features/preview/components/preview-download-file-list.js

@@ -1,67 +0,0 @@
-import PropTypes from 'prop-types'
-import { MenuItem } from 'react-bootstrap'
-import { useTranslation } from 'react-i18next'
-
-export const topFileTypes = ['bbl', 'gls', 'ind']
-
-function PreviewDownloadFileList({ fileList = [] }) {
-  const { t } = useTranslation()
-
-  let topFiles = []
-  let otherFiles = []
-
-  if (fileList) {
-    topFiles = fileList.filter(file => {
-      return topFileTypes.includes(file.type)
-    })
-
-    otherFiles = fileList.filter(file => {
-      if (!topFileTypes.includes(file.type)) {
-        return !(file.type === 'pdf' && file.main === true)
-      }
-      return false
-    })
-  }
-
-  return (
-    <>
-      <MenuItem header>{t('other_output_files')}</MenuItem>
-      <SubFileList subFileList={topFiles} listType="main" />
-      {otherFiles.length > 0 && topFiles.length > 0 ? (
-        <>
-          <MenuItem divider />
-        </>
-      ) : (
-        <></>
-      )}
-      {otherFiles.length > 0 ? (
-        <>
-          <SubFileList subFileList={otherFiles} listType="other" />
-        </>
-      ) : (
-        <></>
-      )}
-    </>
-  )
-}
-
-function SubFileList({ subFileList, listType }) {
-  return subFileList.map((file, index) => {
-    return (
-      <MenuItem download href={file.url} key={`${listType}${index}`}>
-        <b>{file.fileName}</b>
-      </MenuItem>
-    )
-  })
-}
-
-SubFileList.propTypes = {
-  subFileList: PropTypes.array.isRequired,
-  listType: PropTypes.string.isRequired,
-}
-
-PreviewDownloadFileList.propTypes = {
-  fileList: PropTypes.array,
-}
-
-export default PreviewDownloadFileList

services/web/frontend/js/features/preview/components/preview-error.js

@@ -1,184 +0,0 @@
-import PropTypes from 'prop-types'
-import { useTranslation, Trans } from 'react-i18next'
-import PreviewLogsPaneEntry from './preview-logs-pane-entry'
-import Icon from '../../../shared/components/icon'
-import { useEditorContext } from '../../../shared/context/editor-context'
-import StartFreeTrialButton from '../../../shared/components/start-free-trial-button'
-
-function PreviewError({ name }) {
-  const { hasPremiumCompile, isProjectOwner } = useEditorContext({
-    isProjectOwner: PropTypes.bool,
-  })
-
-  const { t } = useTranslation()
-  let errorTitle
-  let errorContent
-
-  if (name === 'error') {
-    errorTitle = t('server_error')
-    errorContent = <>{t('somthing_went_wrong_compiling')}</>
-  } else if (name === 'renderingError') {
-    errorTitle = t('pdf_rendering_error')
-    errorContent = <>{t('something_went_wrong_rendering_pdf')}</>
-  } else if (name === 'clsiMaintenance') {
-    errorTitle = t('server_error')
-    errorContent = <>{t('clsi_maintenance')}</>
-  } else if (name === 'clsiUnavailable') {
-    errorTitle = t('server_error')
-    errorContent = <>{t('clsi_unavailable')}</>
-  } else if (name === 'tooRecentlyCompiled') {
-    errorTitle = t('server_error')
-    errorContent = <>{t('too_recently_compiled')}</>
-  } else if (name === 'compileTerminated') {
-    errorTitle = t('terminated')
-    errorContent = <>{t('compile_terminated_by_user')}</>
-  } else if (name === 'rateLimited') {
-    errorTitle = t('pdf_compile_rate_limit_hit')
-    errorContent = <>{t('project_flagged_too_many_compiles')}</>
-  } else if (name === 'compileInProgress') {
-    errorTitle = t('pdf_compile_in_progress_error')
-    errorContent = <>{t('pdf_compile_try_again')}</>
-  } else if (name === 'timedout') {
-    errorTitle = t('timedout')
-    errorContent = (
-      <>
-        {t('proj_timed_out_reason')}
-        <div>
-          <a
-            href="https://www.overleaf.com/learn/how-to/Why_do_I_keep_getting_the_compile_timeout_error_message%3F"
-            target="_blank"
-            rel="noopener"
-          >
-            {t('learn_how_to_make_documents_compile_quickly')}
-          </a>
-        </div>
-      </>
-    )
-  } else if (name === 'autoCompileDisabled') {
-    errorTitle = t('autocompile_disabled')
-    errorContent = <>{t('autocompile_disabled_reason')}</>
-  } else if (name === 'projectTooLarge') {
-    errorTitle = t('project_too_large')
-    errorContent = <>{t('project_too_much_editable_text')}</>
-  } else if (name === 'failure') {
-    errorTitle = t('no_pdf_error_title')
-    errorContent = (
-      <>
-        <Trans i18nKey="no_pdf_error_explanation" />
-        <ul className="log-entry-formatted-content-list">
-          <li>
-            <Trans i18nKey="no_pdf_error_reason_unrecoverable_error" />
-          </li>
-          <li>
-            <Trans
-              i18nKey="no_pdf_error_reason_no_content"
-              components={{ code: <code /> }}
-            />
-          </li>
-          <li>
-            <Trans
-              i18nKey="no_pdf_error_reason_output_pdf_already_exists"
-              components={{ code: <code /> }}
-            />
-          </li>
-        </ul>
-      </>
-    )
-  }
-
-  return errorTitle ? (
-    <>
-      <PreviewLogsPaneEntry
-        headerTitle={errorTitle}
-        formattedContent={errorContent}
-        entryAriaLabel={t('compile_error_entry_description')}
-        level="error"
-      />
-      {name === 'timedout' &&
-      window.ExposedSettings.enableSubscriptions &&
-      !hasPremiumCompile ? (
-        <TimeoutUpgradePrompt isProjectOwner={isProjectOwner} />
-      ) : null}
-    </>
-  ) : null
-}
-
-function TimeoutUpgradePrompt({ isProjectOwner }) {
-  const { t } = useTranslation()
-
-  const timeoutUpgradePromptContent = (
-    <>
-      <p>{t('free_accounts_have_timeout_upgrade_to_increase')}</p>
-      <p>{t('plus_upgraded_accounts_receive')}:</p>
-      <div>
-        <ul className="list-unstyled">
-          <li>
-            <Icon type="check" />
-            &nbsp;
-            {t('unlimited_projects')}
-          </li>
-          <li>
-            <Icon type="check" />
-            &nbsp;
-            {t('collabs_per_proj', { collabcount: 'Multiple' })}
-          </li>
-          <li>
-            <Icon type="check" />
-            &nbsp;
-            {t('full_doc_history')}
-          </li>
-          <li>
-            <Icon type="check" />
-            &nbsp;
-            {t('sync_to_dropbox')}
-          </li>
-          <li>
-            <Icon type="check" />
-            &nbsp;
-            {t('sync_to_github')}
-          </li>
-          <li>
-            <Icon type="check" />
-            &nbsp;
-            {t('compile_larger_projects')}
-          </li>
-        </ul>
-      </div>
-      {isProjectOwner ? (
-        <p className="text-center">
-          <StartFreeTrialButton
-            source="compile-timeout"
-            buttonStyle="success"
-            classes={{ button: 'row-spaced-small' }}
-          />
-        </p>
-      ) : null}
-    </>
-  )
-  return (
-    <PreviewLogsPaneEntry
-      headerTitle={
-        isProjectOwner
-          ? t('upgrade_for_longer_compiles')
-          : t('ask_proj_owner_to_upgrade_for_longer_compiles')
-      }
-      formattedContent={timeoutUpgradePromptContent}
-      entryAriaLabel={
-        isProjectOwner
-          ? t('upgrade_for_longer_compiles')
-          : t('ask_proj_owner_to_upgrade_for_longer_compiles')
-      }
-      level="success"
-    />
-  )
-}
-
-PreviewError.propTypes = {
-  name: PropTypes.string.isRequired,
-}
-
-TimeoutUpgradePrompt.propTypes = {
-  isProjectOwner: PropTypes.bool.isRequired,
-}
-
-export default PreviewError

services/web/frontend/js/features/preview/components/preview-first-error-pop-up.js

@@ -1,92 +0,0 @@
-import PropTypes from 'prop-types'
-import { useTranslation } from 'react-i18next'
-import Icon from '../../../shared/components/icon'
-import PreviewLogsPaneEntry from './preview-logs-pane-entry'
-import { OverlayTrigger, Tooltip } from 'react-bootstrap'
-
-function PreviewFirstErrorPopUp({
-  logEntry,
-  nErrors,
-  onGoToErrorLocation,
-  onViewLogs,
-  onClose,
-}) {
-  const { t } = useTranslation()
-
-  function handleGoToErrorLocation() {
-    const { file, line, column } = logEntry
-    onGoToErrorLocation({ file, line, column })
-  }
-
-  return (
-    <div
-      className="first-error-popup"
-      role="alertdialog"
-      aria-label={t('first_error_popup_label')}
-    >
-      <PreviewLogsPaneEntry
-        headerTitle={logEntry.message}
-        headerIcon={<FirstErrorPopUpInfoBadge />}
-        rawContent={logEntry.content}
-        formattedContent={logEntry.humanReadableHintComponent}
-        extraInfoURL={logEntry.extraInfoURL}
-        level={logEntry.level}
-        showLineAndNoLink={false}
-        showCloseButton
-        customClass="log-entry-first-error-popup"
-        onClose={onClose}
-      />
-      <div className="first-error-popup-actions">
-        <button
-          className="btn btn-info btn-xs first-error-btn"
-          type="button"
-          onClick={handleGoToErrorLocation}
-        >
-          <Icon type="chain" />
-          &nbsp;
-          {t('go_to_error_location')}
-        </button>
-        <button
-          className="btn btn-info btn-xs first-error-btn"
-          type="button"
-          onClick={onViewLogs}
-        >
-          <Icon type="file-text-o" />
-          &nbsp;
-          {t('view_error', { count: nErrors })}
-        </button>
-      </div>
-    </div>
-  )
-}
-
-function FirstErrorPopUpInfoBadge() {
-  const { t } = useTranslation()
-  const logsPaneInfoMessage = t('logs_pane_info_message_popup')
-  const tooltip = (
-    <Tooltip id="file-tree-badge-tooltip">{logsPaneInfoMessage}</Tooltip>
-  )
-
-  return (
-    <OverlayTrigger placement="bottom" overlay={tooltip} delayHide={100}>
-      <a
-        href="https://forms.gle/AUbDDRvroQ7KFwHR9"
-        target="_blank"
-        rel="noopener noreferrer"
-        className="info-badge-fade-bg"
-      >
-        <span className="sr-only">{logsPaneInfoMessage}</span>
-      </a>
-    </OverlayTrigger>
-  )
-}
-
-PreviewFirstErrorPopUp.propTypes = {
-  logEntry: PropTypes.object.isRequired,
-  nErrors: PropTypes.number.isRequired,
-  onGoToErrorLocation: PropTypes.func.isRequired,
-  onViewLogs: PropTypes.func.isRequired,
-  onClose: PropTypes.func.isRequired,
-}
-
-export default PreviewFirstErrorPopUp

services/web/frontend/js/features/preview/components/preview-logs-pane-entry.js

@@ -1,141 +0,0 @@
-import PropTypes from 'prop-types'
-import classNames from 'classnames'
-import { useTranslation } from 'react-i18next'
-import useExpandCollapse from '../../../shared/hooks/use-expand-collapse'
-import Icon from '../../../shared/components/icon'
-
-import PreviewLogEntryHeader from './preview-log-entry-header'
-
-function PreviewLogsPaneEntry({
-  headerTitle,
-  headerIcon,
-  rawContent,
-  logType,
-  formattedContent,
-  extraInfoURL,
-  level,
-  sourceLocation,
-  showSourceLocationLink = true,
-  showCloseButton = false,
-  entryAriaLabel = null,
-  customClass,
-  onSourceLocationClick,
-  onClose,
-}) {
-  const logEntryClasses = classNames('log-entry', customClass)
-
-  function handleLogEntryLinkClick(e) {
-    e.preventDefault()
-    onSourceLocationClick(sourceLocation)
-  }
-
-  return (
-    <div className={logEntryClasses} aria-label={entryAriaLabel}>
-      <PreviewLogEntryHeader
-        level={level}
-        sourceLocation={sourceLocation}
-        headerTitle={headerTitle}
-        headerIcon={headerIcon}
-        logType={logType}
-        showSourceLocationLink={showSourceLocationLink}
-        onSourceLocationClick={handleLogEntryLinkClick}
-        showCloseButton={showCloseButton}
-        onClose={onClose}
-      />
-      {rawContent || formattedContent ? (
-        <PreviewLogEntryContent
-          rawContent={rawContent}
-          formattedContent={formattedContent}
-          extraInfoURL={extraInfoURL}
-        />
-      ) : null}
-    </div>
-  )
-}
-
-function PreviewLogEntryContent({
-  rawContent,
-  formattedContent,
-  extraInfoURL,
-}) {
-  const { isExpanded, needsExpandCollapse, expandableProps, toggleProps } =
-    useExpandCollapse({
-      collapsedSize: 150,
-    })
-
-  const buttonContainerClasses = classNames(
-    'log-entry-content-button-container',
-    {
-      'log-entry-content-button-container-collapsed': !isExpanded,
-    }
-  )
-
-  const { t } = useTranslation()
-
-  return (
-    <div className="log-entry-content">
-      {formattedContent ? (
-        <div className="log-entry-formatted-content">{formattedContent}</div>
-      ) : null}
-      {extraInfoURL ? (
-        <div className="log-entry-content-link">
-          <a href={extraInfoURL} target="_blank" rel="noopener">
-            {t('log_hint_extra_info')}
-          </a>
-        </div>
-      ) : null}
-      {rawContent ? (
-        <div className="log-entry-content-raw-container">
-          <div {...expandableProps}>
-            <pre className="log-entry-content-raw">{rawContent.trim()}</pre>
-          </div>
-          {needsExpandCollapse ? (
-            <div className={buttonContainerClasses}>
-              <button
-                type="button"
-                className="btn btn-xs btn-default log-entry-btn-expand-collapse"
-                {...toggleProps}
-              >
-                {isExpanded ? (
-                  <>
-                    <Icon type="angle-up" /> {t('collapse')}
-                  </>
-                ) : (
-                  <>
-                    <Icon type="angle-down" /> {t('expand')}
-                  </>
-                )}
-              </button>
-            </div>
-          ) : null}
-        </div>
-      ) : null}
-    </div>
-  )
-}
-
-PreviewLogEntryContent.propTypes = {
-  rawContent: PropTypes.string,
-  formattedContent: PropTypes.node,
-  extraInfoURL: PropTypes.string,
-}
-
-PreviewLogsPaneEntry.propTypes = {
-  sourceLocation: PreviewLogEntryHeader.propTypes.sourceLocation,
-  headerTitle: PropTypes.string,
-  headerIcon: PropTypes.element,
-  rawContent: PropTypes.string,
-  logType: PropTypes.string,
-  formattedContent: PropTypes.node,
-  extraInfoURL: PropTypes.string,
-  level: PropTypes.oneOf(['error', 'warning', 'typesetting', 'raw', 'success'])
-    .isRequired,
-  customClass: PropTypes.string,
-  showSourceLocationLink: PropTypes.bool,
-  showCloseButton: PropTypes.bool,
-  entryAriaLabel: PropTypes.string,
-  onSourceLocationClick: PropTypes.func,
-  onClose: PropTypes.func,
-}
-
-export default PreviewLogsPaneEntry

services/web/frontend/js/features/preview/components/preview-logs-pane.js

@@ -1,268 +0,0 @@
-import PropTypes from 'prop-types'
-import { useTranslation } from 'react-i18next'
-import { Dropdown } from 'react-bootstrap'
-import PreviewLogsPaneEntry from './preview-logs-pane-entry'
-import PreviewLogsPaneMaxEntries from './preview-logs-pane-max-entries'
-import PreviewValidationIssue from './preview-validation-issue'
-import PreviewDownloadFileList from './preview-download-file-list'
-import PreviewError from './preview-error'
-import Icon from '../../../shared/components/icon'
-import usePersistedState from '../../../shared/hooks/use-persisted-state'
-import ControlledDropdown from '../../../shared/components/controlled-dropdown'
-
-const LOG_PREVIEW_LIMIT = 100
-
-function PreviewLogsPane({
-  logEntries = { all: [], errors: [], warnings: [], typesetting: [] },
-  rawLog = '',
-  validationIssues = {},
-  errors = {},
-  outputFiles = [],
-  isClearingCache,
-  isCompiling = false,
-  autoCompileHasLintingError = false,
-  variantWithFirstErrorPopup,
-  onLogEntryLocationClick,
-  onClearCache,
-}) {
-  const { t } = useTranslation()
-  const {
-    all: allCompilerIssues = [],
-    errors: compilerErrors = [],
-    warnings: compilerWarnings = [],
-    typesetting: compilerTypesettingIssues = [],
-  } = logEntries
-  const allLogEntries = [
-    ...compilerErrors,
-    ...compilerWarnings,
-    ...compilerTypesettingIssues,
-  ]
-
-  const actionsUI = (
-    <div className="logs-pane-actions">
-      <button
-        className="btn btn-sm btn-danger logs-pane-actions-clear-cache"
-        onClick={onClearCache}
-        disabled={isClearingCache || isCompiling}
-      >
-        {isClearingCache ? (
-          <Icon type="refresh" spin />
-        ) : (
-          <Icon type="trash-o" />
-        )}
-        &nbsp;
-        <span>{t('clear_cached_files')}</span>
-      </button>
-      <ControlledDropdown
-        id="dropdown-files-logs-pane"
-        dropup
-        pullRight
-        disabled={isCompiling}
-      >
-        <Dropdown.Toggle
-          className="btn btn-sm btn-info dropdown-toggle"
-          title={t('other_logs_and_files')}
-          bsStyle="info"
-        />
-        <Dropdown.Menu id="dropdown-files-logs-pane-list">
-          <PreviewDownloadFileList fileList={outputFiles} />
-        </Dropdown.Menu>
-      </ControlledDropdown>
-    </div>
-  )
-
-  const rawLogUI = (
-    <PreviewLogsPaneEntry
-      headerTitle={t('raw_logs')}
-      rawContent={rawLog}
-      entryAriaLabel={t('raw_logs_description')}
-      level="raw"
-    />
-  )
-
-  return (
-    <div className="logs-pane">
-      <div className="logs-pane-content">
-        <LogsPaneInfoNotice
-          variantWithFirstErrorPopup={variantWithFirstErrorPopup}
-        />
-        {autoCompileHasLintingError ? <AutoCompileLintingErrorEntry /> : null}
-        {errors ? <PreviewErrors errors={errors} /> : null}
-        {validationIssues ? (
-          <PreviewValidationIssues validationIssues={validationIssues} />
-        ) : null}
-        {allCompilerIssues.length > 0 ? (
-          <PreviewLogEntries
-            logEntries={allLogEntries}
-            onLogEntryLocationClick={onLogEntryLocationClick}
-          />
-        ) : null}
-        {rawLog && rawLog !== '' ? rawLogUI : null}
-        {actionsUI}
-      </div>
-    </div>
-  )
-}
-
-const PreviewErrors = ({ errors }) => {
-  const nowTS = Date.now()
-  return Object.entries(errors).map(([name, exists], index) => {
-    return exists && <PreviewError key={`${nowTS}-${index}`} name={name} />
-  })
-}
-
-const PreviewValidationIssues = ({ validationIssues }) => {
-  const nowTS = Date.now()
-  return Object.keys(validationIssues).map((name, index) => (
-    <PreviewValidationIssue
-      key={`${nowTS}-${index}`}
-      name={name}
-      details={validationIssues[name]}
-    />
-  ))
-}
-const PreviewLogEntries = ({ logEntries, onLogEntryLocationClick }) => {
-  const { t } = useTranslation()
-  const nowTS = Date.now()
-
-  const totalLogEntries = logEntries.length
-
-  if (totalLogEntries > LOG_PREVIEW_LIMIT) {
-    logEntries = logEntries.slice(0, 100)
-  }
-
-  logEntries = logEntries.map((logEntry, index) => (
-    <PreviewLogsPaneEntry
-      key={`${nowTS}-${index}`}
-      headerTitle={logEntry.message}
-      rawContent={logEntry.content}
-      logType={logEntry.type}
-      formattedContent={logEntry.humanReadableHintComponent}
-      extraInfoURL={logEntry.extraInfoURL}
-      level={logEntry.level}
-      entryAriaLabel={t('log_entry_description', {
-        level: logEntry.level,
-      })}
-      sourceLocation={{
-        file: logEntry.file,
-        line: logEntry.line,
-        column: logEntry.column,
-      }}
-      onSourceLocationClick={onLogEntryLocationClick}
-    />
-  ))
-
-  if (totalLogEntries > LOG_PREVIEW_LIMIT) {
-    // Prepend log limit exceeded message to logs array
-    logEntries = [
-      <PreviewLogsPaneMaxEntries
-        key={`${nowTS}-${LOG_PREVIEW_LIMIT}`}
-        totalEntries={totalLogEntries}
-        entriesShown={LOG_PREVIEW_LIMIT}
-      />,
-    ].concat(logEntries)
-  }
-
-  return logEntries
-}
-
-function AutoCompileLintingErrorEntry() {
-  const { t } = useTranslation()
-  return (
-    <div className="log-entry">
-      <div className="log-entry-header log-entry-header-error">
-        <div className="log-entry-header-icon-container">
-          <Icon type="exclamation-triangle" fw />
-        </div>
-        <h3 className="log-entry-header-title">
-          {t('code_check_failed_explanation')}
-        </h3>
-      </div>
-    </div>
-  )
-}
-
-// exported to be used by pdf-viewer during React migration
-export function LogsPaneInfoNotice({ variantWithFirstErrorPopup }) {
-  const { t } = useTranslation()
-  const [dismissedInfoNotice, setDismissedInfoNotice] = usePersistedState(
-    `logs_pane.dismissed_info_notice`,
-    false
-  )
-
-  const surveyLink = variantWithFirstErrorPopup
-    ? 'https://forms.gle/AUbDDRvroQ7KFwHR9'
-    : 'https://forms.gle/bRxevtGzBHRk8BKw8'
-  function handleDismissButtonClick() {
-    setDismissedInfoNotice(true)
-  }
-
-  return dismissedInfoNotice ? null : (
-    <div className="log-entry">
-      <div className="log-entry-header log-entry-header-raw">
-        <div className="log-entry-header-icon-container">
-          <span className="info-badge" />
-        </div>
-        <h3 className="log-entry-header-title">
-          {t('logs_pane_info_message')}
-        </h3>
-        <a
-          href={surveyLink}
-          target="_blank"
-          rel="noopener noreferrer"
-          className="log-entry-header-link log-entry-header-link-raw"
-        >
-          <span className="log-entry-header-link-location">
-            {t('give_feedback')}
-          </span>
-        </a>
-        <button
-          className="btn-inline-link log-entry-header-link"
-          type="button"
-          aria-label={t('dismiss')}
-          onClick={handleDismissButtonClick}
-        >
-          <span aria-hidden="true">&times;</span>
-        </button>
-      </div>
-    </div>
-  )
-}
-
-PreviewErrors.propTypes = {
-  errors: PropTypes.object.isRequired,
-}
-
-PreviewValidationIssues.propTypes = {
-  validationIssues: PropTypes.object.isRequired,
-}
-
-PreviewLogEntries.propTypes = {
-  logEntries: PropTypes.array.isRequired,
-  onLogEntryLocationClick: PropTypes.func.isRequired,
-}
-
-LogsPaneInfoNotice.propTypes = {
-  variantWithFirstErrorPopup: PropTypes.bool,
-}
-
-PreviewLogsPane.propTypes = {
-  logEntries: PropTypes.shape({
-    all: PropTypes.array,
-    errors: PropTypes.array,
-    warning: PropTypes.array,
-    typesetting: PropTypes.array,
-  }),
-  autoCompileHasLintingError: PropTypes.bool,
-  rawLog: PropTypes.string,
-  outputFiles: PropTypes.array,
-  isClearingCache: PropTypes.bool,
-  isCompiling: PropTypes.bool,
-  variantWithFirstErrorPopup: PropTypes.bool,
-  onLogEntryLocationClick: PropTypes.func.isRequired,
-  onClearCache: PropTypes.func.isRequired,
-  validationIssues: PropTypes.object,
-  errors: PropTypes.object,
-}
-
-export default PreviewLogsPane

services/web/frontend/js/features/preview/components/preview-logs-toggle-button.js

@@ -1,207 +0,0 @@
-import { OverlayTrigger, Tooltip } from 'react-bootstrap'
-import PropTypes from 'prop-types'
-import classNames from 'classnames'
-import { useTranslation } from 'react-i18next'
-import Icon from '../../../shared/components/icon'
-
-const MAX_ERRORS_COUNT = 99
-
-function PreviewLogsToggleButton({
-  onToggle,
-  showLogs,
-  autoCompileLintingError = false,
-  compileFailed = false,
-  logsState: { nErrors, nWarnings },
-  showText,
-}) {
-  const { t } = useTranslation()
-  let textStyle = {}
-  let btnColorCssClass = 'btn-default'
-  let buttonContents
-
-  if (!showText) {
-    textStyle = {
-      position: 'absolute',
-      right: '-100vw',
-    }
-  }
-
-  function handleOnClick(e) {
-    e.currentTarget.blur()
-    onToggle()
-  }
-
-  if (showLogs) {
-    buttonContents = <ViewPdf textStyle={textStyle} />
-  } else {
-    buttonContents = (
-      <CompilationResult
-        textStyle={textStyle}
-        autoCompileLintingError={autoCompileLintingError}
-        nErrors={nErrors}
-        nWarnings={nWarnings}
-      />
-    )
-    if (autoCompileLintingError || nErrors > 0) {
-      btnColorCssClass = 'btn-danger'
-    } else if (nWarnings > 0) {
-      btnColorCssClass = 'btn-warning'
-    }
-  }
-  const buttonClasses = classNames(
-    'btn',
-    'btn-xs',
-    'btn-toggle-logs',
-    'toolbar-item',
-    btnColorCssClass
-  )
-
-  const buttonElement = (
-    <button
-      id="logs-toggle"
-      type="button"
-      disabled={compileFailed}
-      className={buttonClasses}
-      onClick={handleOnClick}
-    >
-      {buttonContents}
-    </button>
-  )
-
-  return showText ? (
-    buttonElement
-  ) : (
-    <OverlayTrigger
-      placement="bottom"
-      overlay={
-        <Tooltip id="tooltip-logs-toggle">
-          {showLogs ? t('view_pdf') : t('view_logs')}
-        </Tooltip>
-      }
-    >
-      {buttonElement}
-    </OverlayTrigger>
-  )
-}
-
-function CompilationResult({
-  textStyle,
-  autoCompileLintingError,
-  nErrors,
-  nWarnings,
-}) {
-  if (autoCompileLintingError) {
-    return <AutoCompileLintingError textStyle={textStyle} />
-  } else if (nErrors || nWarnings) {
-    return (
-      <LogsCompilationResult
-        logType={nErrors ? 'errors' : 'warnings'}
-        nLogs={nErrors || nWarnings}
-        textStyle={textStyle}
-      />
-    )
-  } else {
-    return <ViewLogs textStyle={textStyle} />
-  }
-}
-
-function ViewPdf({ textStyle }) {
-  const { t } = useTranslation()
-  return (
-    <>
-      <Icon type="file-pdf-o" />
-      <span className="toolbar-text" style={textStyle}>
-        {t('view_pdf')}
-      </span>
-    </>
-  )
-}
-
-function LogsCompilationResult({ textStyle, logType, nLogs }) {
-  const { t } = useTranslation()
-
-  const logTypeLabel =
-    logType === 'errors'
-      ? t('your_project_has_an_error', { count: nLogs })
-      : t('view_warning', { count: nLogs })
-
-  const errorCountLabel = ` (${
-    nLogs > MAX_ERRORS_COUNT ? `${MAX_ERRORS_COUNT}+` : nLogs
-  })`
-
-  return (
-    <>
-      <Icon type="file-text-o" />
-      <span
-        className="btn-toggle-logs-label toolbar-text"
-        aria-label={logTypeLabel}
-        style={textStyle}
-      >
-        {`${logTypeLabel}${nLogs > 1 ? errorCountLabel : ''}`}
-      </span>
-    </>
-  )
-}
-
-function AutoCompileLintingError({ textStyle }) {
-  const { t } = useTranslation()
-  return (
-    <>
-      <Icon type="exclamation-triangle" />
-      <span className="toolbar-text" style={textStyle}>
-        {t('code_check_failed')}
-      </span>
-    </>
-  )
-}
-
-function ViewLogs({ textStyle }) {
-  const { t } = useTranslation()
-  return (
-    <>
-      <Icon type="file-text-o" />
-      <span className="toolbar-text" style={textStyle}>
-        {t('view_logs')}
-      </span>
-    </>
-  )
-}
-
-PreviewLogsToggleButton.propTypes = {
-  onToggle: PropTypes.func.isRequired,
-  logsState: PropTypes.shape({
-    nErrors: PropTypes.number.isRequired,
-    nWarnings: PropTypes.number.isRequired,
-  }),
-  showLogs: PropTypes.bool.isRequired,
-  showText: PropTypes.bool.isRequired,
-  compileFailed: PropTypes.bool,
-  autoCompileLintingError: PropTypes.bool,
-}
-
-CompilationResult.propTypes = {
-  textStyle: PropTypes.object.isRequired,
-  autoCompileLintingError: PropTypes.bool,
-  nErrors: PropTypes.number.isRequired,
-  nWarnings: PropTypes.number.isRequired,
-}
-
-LogsCompilationResult.propTypes = {
-  logType: PropTypes.string.isRequired,
-  nLogs: PropTypes.number.isRequired,
-  textStyle: PropTypes.object.isRequired,
-}
-
-AutoCompileLintingError.propTypes = {
-  textStyle: PropTypes.object.isRequired,
-}
-
-ViewLogs.propTypes = {
-  textStyle: PropTypes.object.isRequired,
-}
-
-ViewPdf.propTypes = {
-  textStyle: PropTypes.object.isRequired,
-}
-
-export default PreviewLogsToggleButton

services/web/frontend/js/features/preview/components/preview-pane.js

@@ -1,177 +0,0 @@
-import { useState } from 'react'
-import PropTypes from 'prop-types'
-import PreviewToolbar from './preview-toolbar'
-import PreviewLogsPane from './preview-logs-pane'
-import PreviewFirstErrorPopUp from './preview-first-error-pop-up'
-import { useTranslation } from 'react-i18next'
-
-function PreviewPane({
-  compilerState,
-  onClearCache,
-  onRecompile,
-  onRecompileFromScratch,
-  onRunSyntaxCheckNow,
-  onSetAutoCompile,
-  onSetDraftMode,
-  onSetSyntaxCheck,
-  onToggleLogs,
-  onSetFullLayout,
-  onSetSplitLayout,
-  onStopCompilation,
-  outputFiles,
-  pdfDownloadUrl,
-  onLogEntryLocationClick,
-  showLogs,
-  variantWithFirstErrorPopup = true,
-  splitLayout,
-}) {
-  const { t } = useTranslation()
-
-  const [lastCompileTimestamp, setLastCompileTimestamp] = useState(
-    compilerState.lastCompileTimestamp
-  )
-  const [seenLogsForCurrentCompile, setSeenLogsForCurrentCompile] =
-    useState(false)
-  const [dismissedFirstErrorPopUp, setDismissedFirstErrorPopUp] =
-    useState(false)
-
-  if (lastCompileTimestamp < compilerState.lastCompileTimestamp) {
-    setLastCompileTimestamp(compilerState.lastCompileTimestamp)
-    setSeenLogsForCurrentCompile(false)
-  }
-
-  if (showLogs && !seenLogsForCurrentCompile) {
-    setSeenLogsForCurrentCompile(true)
-  }
-
-  const nErrors =
-    compilerState.logEntries && compilerState.logEntries.errors
-      ? compilerState.logEntries.errors.length
-      : 0
-  const nWarnings =
-    compilerState.logEntries && compilerState.logEntries.warnings
-      ? compilerState.logEntries.warnings.length
-      : 0
-
-  const hasCLSIErrors =
-    compilerState.errors &&
-    Object.keys(compilerState.errors).length > 0 &&
-    compilerState.compileFailed &&
-    !compilerState.isCompiling
-
-  const hasValidationIssues =
-    compilerState.validationIssues &&
-    Object.keys(compilerState.validationIssues).length > 0 &&
-    compilerState.compileFailed &&
-    !compilerState.isCompiling
-
-  const showFirstErrorPopUp =
-    variantWithFirstErrorPopup &&
-    nErrors > 0 &&
-    !seenLogsForCurrentCompile &&
-    !dismissedFirstErrorPopUp &&
-    !compilerState.isCompiling
-
-  function handleFirstErrorPopUpClose() {
-    setDismissedFirstErrorPopUp(true)
-  }
-
-  return (
-    <>
-      <PreviewToolbar
-        compilerState={compilerState}
-        logsState={{ nErrors, nWarnings }}
-        showLogs={showLogs}
-        onRecompile={onRecompile}
-        onRecompileFromScratch={onRecompileFromScratch}
-        onRunSyntaxCheckNow={onRunSyntaxCheckNow}
-        onSetAutoCompile={onSetAutoCompile}
-        onSetDraftMode={onSetDraftMode}
-        onSetSyntaxCheck={onSetSyntaxCheck}
-        onToggleLogs={onToggleLogs}
-        onSetSplitLayout={onSetSplitLayout}
-        onSetFullLayout={onSetFullLayout}
-        onStopCompilation={onStopCompilation}
-        outputFiles={outputFiles}
-        pdfDownloadUrl={pdfDownloadUrl}
-        splitLayout={splitLayout}
-      />
-      <span aria-live="polite" className="sr-only">
-        {hasCLSIErrors ? t('compile_error_description') : ''}
-      </span>
-      <span aria-live="polite" className="sr-only">
-        {hasValidationIssues ? t('validation_issue_description') : ''}
-      </span>
-      <span aria-live="polite" className="sr-only">
-        {nErrors && !compilerState.isCompiling
-          ? t('n_errors', { count: nErrors })
-          : ''}
-      </span>
-      <span aria-live="polite" className="sr-only">
-        {nWarnings && !compilerState.isCompiling
-          ? t('n_warnings', { count: nWarnings })
-          : ''}
-      </span>
-      {showFirstErrorPopUp ? (
-        <PreviewFirstErrorPopUp
-          logEntry={compilerState.logEntries.errors[0]}
-          nErrors={nErrors}
-          onGoToErrorLocation={onLogEntryLocationClick}
-          onViewLogs={onToggleLogs}
-          onClose={handleFirstErrorPopUpClose}
-        />
-      ) : null}
-      {showLogs ? (
-        <PreviewLogsPane
-          logEntries={compilerState.logEntries}
-          rawLog={compilerState.rawLog}
-          validationIssues={compilerState.validationIssues}
-          errors={compilerState.errors}
-          autoCompileHasLintingError={compilerState.autoCompileHasLintingError}
-          outputFiles={outputFiles}
-          onLogEntryLocationClick={onLogEntryLocationClick}
-          isClearingCache={compilerState.isClearingCache}
-          isCompiling={compilerState.isCompiling}
-          variantWithFirstErrorPopup={variantWithFirstErrorPopup}
-          onClearCache={onClearCache}
-        />
-      ) : null}
-    </>
-  )
-}
-
-PreviewPane.propTypes = {
-  compilerState: PropTypes.shape({
-    autoCompileHasLintingError: PropTypes.bool,
-    isAutoCompileOn: PropTypes.bool.isRequired,
-    isCompiling: PropTypes.bool.isRequired,
-    isDraftModeOn: PropTypes.bool.isRequired,
-    isSyntaxCheckOn: PropTypes.bool.isRequired,
-    isClearingCache: PropTypes.bool.isRequired,
-    lastCompileTimestamp: PropTypes.number,
-    logEntries: PropTypes.object,
-    validationIssues: PropTypes.object,
-    errors: PropTypes.object,
-    rawLog: PropTypes.string,
-    compileFailed: PropTypes.bool,
-  }),
-  onClearCache: PropTypes.func.isRequired,
-  onLogEntryLocationClick: PropTypes.func.isRequired,
-  onRecompile: PropTypes.func.isRequired,
-  onRecompileFromScratch: PropTypes.func.isRequired,
-  onRunSyntaxCheckNow: PropTypes.func.isRequired,
-  onSetAutoCompile: PropTypes.func.isRequired,
-  onSetDraftMode: PropTypes.func.isRequired,
-  onSetSyntaxCheck: PropTypes.func.isRequired,
-  onSetSplitLayout: PropTypes.func.isRequired,
-  onSetFullLayout: PropTypes.func.isRequired,
-  onStopCompilation: PropTypes.func.isRequired,
-  onToggleLogs: PropTypes.func.isRequired,
-  outputFiles: PropTypes.array,
-  pdfDownloadUrl: PropTypes.string,
-  showLogs: PropTypes.bool.isRequired,
-  variantWithFirstErrorPopup: PropTypes.bool,
-  splitLayout: PropTypes.bool.isRequired,
-}
-
-export default PreviewPane

services/web/frontend/js/features/preview/components/preview-recompile-button.js

@@ -1,193 +0,0 @@
-import PropTypes from 'prop-types'
-import { Dropdown, MenuItem, OverlayTrigger, Tooltip } from 'react-bootstrap'
-import { useTranslation } from 'react-i18next'
-import classNames from 'classnames'
-import Icon from '../../../shared/components/icon'
-import ControlledDropdown from '../../../shared/components/controlled-dropdown'
-
-function PreviewRecompileButton({
-  compilerState: {
-    autoCompileHasChanges,
-    autoCompileHasLintingError,
-    isAutoCompileOn,
-    isCompiling,
-    isDraftModeOn,
-    isSyntaxCheckOn,
-  },
-  onRecompile,
-  onRecompileFromScratch,
-  onRunSyntaxCheckNow,
-  onStopCompilation,
-  onSetAutoCompile,
-  onSetDraftMode,
-  onSetSyntaxCheck,
-  showText,
-}) {
-  const { t } = useTranslation()
-
-  function handleSelectAutoCompileOn() {
-    onSetAutoCompile(true)
-  }
-
-  function handleSelectAutoCompileOff() {
-    onSetAutoCompile(false)
-  }
-
-  function handleSelectDraftModeOn() {
-    onSetDraftMode(true)
-  }
-
-  function handleSelectDraftModeOff() {
-    onSetDraftMode(false)
-  }
-
-  function handleSelectSyntaxCheckOn() {
-    onSetSyntaxCheck(true)
-  }
-
-  function handleSelectSyntaxCheckOff() {
-    onSetSyntaxCheck(false)
-  }
-
-  let compilingProps = {}
-  let recompileProps = {}
-  function _hideText(keepAria) {
-    return {
-      'aria-hidden': !keepAria,
-      style: {
-        position: 'absolute',
-        right: '-100vw',
-      },
-    }
-  }
-
-  if (!showText) {
-    compilingProps = _hideText(isCompiling)
-    recompileProps = _hideText(!isCompiling)
-  } else if (isCompiling) {
-    recompileProps = _hideText()
-  } else {
-    compilingProps = _hideText()
-  }
-
-  const recompileButtonGroupClasses = classNames(
-    'btn-recompile-group',
-    'toolbar-item',
-    {
-      'btn-recompile-group-has-changes':
-        autoCompileHasChanges && !autoCompileHasLintingError,
-    }
-  )
-
-  const buttonElement = (
-    <ControlledDropdown
-      id="pdf-recompile-dropdown"
-      className={recompileButtonGroupClasses}
-    >
-      <button className="btn btn-recompile" onClick={() => onRecompile()}>
-        <Icon type="refresh" spin={isCompiling} />
-
-        <span id="text-compiling" className="toolbar-text" {...compilingProps}>
-          {t('compiling')}
-          &hellip;
-        </span>
-
-        <span id="text-recompile" className="toolbar-text" {...recompileProps}>
-          {t('recompile')}
-        </span>
-      </button>
-      <Dropdown.Toggle
-        aria-label={t('toggle_compile_options_menu')}
-        className="btn btn-recompile"
-        bsStyle="success"
-      />
-      <Dropdown.Menu>
-        <MenuItem header>{t('auto_compile')}</MenuItem>
-        <MenuItem onSelect={handleSelectAutoCompileOn}>
-          <Icon type={isAutoCompileOn ? 'check' : ''} fw />
-          {t('on')}
-        </MenuItem>
-        <MenuItem onSelect={handleSelectAutoCompileOff}>
-          <Icon type={!isAutoCompileOn ? 'check' : ''} fw />
-          {t('off')}
-        </MenuItem>
-        <MenuItem header>{t('compile_mode')}</MenuItem>
-        <MenuItem onSelect={handleSelectDraftModeOff}>
-          <Icon type={!isDraftModeOn ? 'check' : ''} fw />
-          {t('normal')}
-        </MenuItem>
-        <MenuItem onSelect={handleSelectDraftModeOn}>
-          <Icon type={isDraftModeOn ? 'check' : ''} fw />
-          {t('fast')} <span className="subdued">[draft]</span>
-        </MenuItem>
-        <MenuItem header>Syntax Checks</MenuItem>
-        <MenuItem onSelect={handleSelectSyntaxCheckOn}>
-          <Icon type={isSyntaxCheckOn ? 'check' : ''} fw />
-          {t('stop_on_validation_error')}
-        </MenuItem>
-        <MenuItem onSelect={handleSelectSyntaxCheckOff}>
-          <Icon type={!isSyntaxCheckOn ? 'check' : ''} fw />
-          {t('ignore_validation_errors')}
-        </MenuItem>
-        <MenuItem onSelect={onRunSyntaxCheckNow}>
-          <Icon type="" fw />
-          {t('run_syntax_check_now')}
-        </MenuItem>
-        <MenuItem className={!isCompiling ? 'hidden' : ''} divider />
-        <MenuItem
-          onSelect={onStopCompilation}
-          className={!isCompiling ? 'hidden' : ''}
-          disabled={!isCompiling}
-          aria-disabled={!isCompiling}
-        >
-          {t('stop_compile')}
-        </MenuItem>
-        <MenuItem divider />
-        <MenuItem
-          onSelect={onRecompileFromScratch}
-          disabled={isCompiling}
-          aria-disabled={!!isCompiling}
-        >
-          {t('recompile_from_scratch')}
-        </MenuItem>
-      </Dropdown.Menu>
-    </ControlledDropdown>
-  )
-
-  return showText ? (
-    buttonElement
-  ) : (
-    <OverlayTrigger
-      placement="bottom"
-      overlay={
-        <Tooltip id="tooltip-download-pdf">
-          {isCompiling ? t('compiling') : t('recompile')}
-        </Tooltip>
-      }
-    >
-      {buttonElement}
-    </OverlayTrigger>
-  )
-}
-
-PreviewRecompileButton.propTypes = {
-  compilerState: PropTypes.shape({
-    autoCompileHasChanges: PropTypes.bool.isRequired,
-    autoCompileHasLintingError: PropTypes.bool,
-    isAutoCompileOn: PropTypes.bool.isRequired,
-    isCompiling: PropTypes.bool.isRequired,
-    isDraftModeOn: PropTypes.bool.isRequired,
-    isSyntaxCheckOn: PropTypes.bool.isRequired,
-    logEntries: PropTypes.object.isRequired,
-  }),
-  onRecompile: PropTypes.func.isRequired,
-  onRecompileFromScratch: PropTypes.func.isRequired,
-  onRunSyntaxCheckNow: PropTypes.func.isRequired,
-  onSetAutoCompile: PropTypes.func.isRequired,
-  onSetDraftMode: PropTypes.func.isRequired,
-  onSetSyntaxCheck: PropTypes.func.isRequired,
-  onStopCompilation: PropTypes.func.isRequired,
-  showText: PropTypes.bool.isRequired,
-}
-
-export default PreviewRecompileButton

services/web/frontend/js/features/preview/components/preview-toolbar.js

@@ -1,291 +0,0 @@
-import { useRef, useState } from 'react'
-import PropTypes from 'prop-types'
-import { OverlayTrigger, Tooltip } from 'react-bootstrap'
-import { useTranslation } from 'react-i18next'
-import PreviewDownloadButton from './preview-download-button'
-import PreviewRecompileButton from './preview-recompile-button'
-import PreviewLogsToggleButton from './preview-logs-toggle-button'
-import useResizeObserver from '../hooks/use-resize-observer'
-import Icon from '../../../shared/components/icon'
-
-function _getElementWidth(element) {
-  if (!element) return 0
-  return Math.ceil(element.getBoundingClientRect().width)
-}
-
-function PreviewToolbar({
-  compilerState,
-  logsState,
-  onRecompileFromScratch,
-  onRecompile,
-  onRunSyntaxCheckNow,
-  onSetAutoCompile,
-  onSetDraftMode,
-  onSetSyntaxCheck,
-  onToggleLogs,
-  onSetSplitLayout,
-  onSetFullLayout,
-  onStopCompilation,
-  outputFiles,
-  pdfDownloadUrl,
-  showLogs,
-  splitLayout,
-}) {
-  const showTextRef = useRef(true)
-  const showToggleTextRef = useRef(true)
-  const toolbarRef = useRef()
-  const recompileWidthDifferenceRef = useRef()
-  const recompileLongerTextRef = useRef()
-  const [showText, setShowText] = useState(showTextRef.current)
-  const [showToggleText, setShowToggleText] = useState(
-    showToggleTextRef.current
-  )
-  const { t } = useTranslation()
-
-  function checkCanShowText(observedElement) {
-    // toolbar items can be in 3 states:
-    // all text, only toggle logs w/text and icons on others, all icons
-    // states depend on available space in the toolbar
-    const toolbarWidth =
-      observedElement &&
-      observedElement.contentRect &&
-      observedElement.contentRect.width
-    if (!toolbarWidth) return
-
-    _checkRecompileStateWidths()
-
-    let textWidths = 0
-    let itemsWidth = _getItemsWidth() // could be with or without text
-
-    // get widths of text only
-    // required for _checkToggleText, even if currently showing text
-    const textElements = toolbarRef.current.querySelectorAll('.toolbar-text')
-    textElements.forEach(item => {
-      if (item.getAttribute('aria-hidden') !== 'true') {
-        textWidths += _getElementWidth(item)
-      }
-    })
-
-    const logsToggleText = toolbarRef.current.querySelector(
-      '#logs-toggle .toolbar-text'
-    )
-    const logsToggleTextWidth = _getElementWidth(logsToggleText)
-
-    if (!showTextRef.current && !showToggleTextRef.current) {
-      // itemsWidth was calculated without any text shown
-      itemsWidth += textWidths
-    } else if (!showTextRef.current && showToggleTextRef.current) {
-      // itemsWidth was calculated with toggle text but no other text
-      // only add text width for other items and then
-      // subtract toggle text width, since it is already in itemsWidth
-      itemsWidth += parseInt(textWidths - logsToggleTextWidth, 10)
-    }
-
-    // only add extra if recompile button is in state with smaller length
-    if (
-      recompileWidthDifferenceRef.current &&
-      recompileLongerTextRef.current &&
-      ((!compilerState.isCompiling &&
-        recompileLongerTextRef.current === 'compiling') ||
-        (compilerState.isCompiling &&
-          recompileLongerTextRef.current === 'recompile'))
-    ) {
-      itemsWidth += recompileWidthDifferenceRef.current
-    }
-
-    itemsWidth += 10 // add extra for some spacing between items
-
-    const canShowText = itemsWidth < toolbarWidth
-
-    if (!canShowText) {
-      _checkToggleText(
-        toolbarWidth,
-        logsToggleTextWidth,
-        itemsWidth,
-        textWidths
-      )
-    } else if (showToggleTextRef.current !== true) {
-      setShowToggleText(true)
-      showToggleTextRef.current = true
-    }
-
-    setShowText(canShowText)
-    showTextRef.current = canShowText
-  }
-
-  function _checkRecompileStateWidths() {
-    // check recompile/compiling button text.
-    // Do not want to hide and then show text when recompiling
-    if (
-      recompileWidthDifferenceRef.current ||
-      recompileWidthDifferenceRef.current === 0
-    )
-      return
-
-    const textCompiling = toolbarRef.current.querySelector('#text-compiling')
-    const textRecompile = toolbarRef.current.querySelector('#text-recompile')
-
-    const textCompilingWidth = _getElementWidth(textCompiling)
-    const textRecompileWidth = _getElementWidth(textRecompile)
-
-    const textLengthDifference = Math.abs(
-      parseInt(textCompilingWidth - textRecompileWidth, 10)
-    )
-    recompileWidthDifferenceRef.current = textLengthDifference
-    // ignore if equal
-    if (textRecompileWidth > textCompilingWidth) {
-      recompileLongerTextRef.current = 'recompile'
-    } else if (textRecompileWidth < textCompilingWidth) {
-      recompileLongerTextRef.current = 'compiling'
-    }
-  }
-
-  function _checkToggleText(
-    toolbarWidth,
-    logsToggleTextWidth,
-    itemsWithTextWidth,
-    textWidths
-  ) {
-    // check to see if we can still show the toggle button text
-    let toggleWithTextWidth = 0
-    let toggleWithoutTextWidth = 0
-    const itemsWithoutTextWidth = parseInt(itemsWithTextWidth - textWidths, 10)
-    const logsToggle = toolbarRef.current.querySelector('#logs-toggle')
-    const logsToggleWidth = _getElementWidth(logsToggle)
-
-    // logsToggleWidth could be with or without text
-    if (showToggleTextRef.current) {
-      toggleWithTextWidth = logsToggleWidth
-      toggleWithoutTextWidth = parseInt(
-        logsToggleWidth - logsToggleTextWidth,
-        10
-      )
-    } else {
-      toggleWithTextWidth = parseInt(logsToggleWidth + logsToggleTextWidth, 10)
-      toggleWithoutTextWidth = logsToggleWidth
-    }
-
-    const itemsWithoutTextAndToggleWidth = parseInt(
-      itemsWithoutTextWidth - toggleWithoutTextWidth,
-      10
-    )
-    const itemsWithIconsExceptToggleWidth = parseInt(
-      itemsWithoutTextAndToggleWidth + toggleWithTextWidth,
-      10
-    )
-    const canShowToggleText = itemsWithIconsExceptToggleWidth < toolbarWidth
-
-    if (canShowToggleText !== showToggleTextRef.current) {
-      setShowToggleText(canShowToggleText)
-      showToggleTextRef.current = canShowToggleText
-    }
-  }
-
-  function _getItemsWidth() {
-    const toolbarItems = toolbarRef.current.querySelectorAll('.toolbar-item')
-    let itemWidth = 0
-    toolbarItems.forEach(item => {
-      itemWidth += _getElementWidth(item)
-    })
-    return itemWidth
-  }
-
-  const pdfExpandLabel = splitLayout ? t('full_screen') : t('split_screen')
-  const pdfExpandIconType = splitLayout ? 'expand' : 'compress'
-  const pdfExpandTooltip = (
-    <Tooltip id="expand-pdf-btn">{pdfExpandLabel}</Tooltip>
-  )
-
-  function handlePdfExpandBtnClick() {
-    if (splitLayout) {
-      onSetFullLayout()
-    } else {
-      onSetSplitLayout()
-    }
-  }
-
-  useResizeObserver(toolbarRef, logsState, checkCanShowText)
-
-  return (
-    <div
-      className="toolbar toolbar-pdf"
-      id="toolbar-preview"
-      data-testid="toolbar-preview"
-      ref={toolbarRef}
-    >
-      <div className="toolbar-pdf-left">
-        <PreviewRecompileButton
-          compilerState={compilerState}
-          onRecompile={onRecompile}
-          onRecompileFromScratch={onRecompileFromScratch}
-          onRunSyntaxCheckNow={onRunSyntaxCheckNow}
-          onSetAutoCompile={onSetAutoCompile}
-          onSetDraftMode={onSetDraftMode}
-          onSetSyntaxCheck={onSetSyntaxCheck}
-          onStopCompilation={onStopCompilation}
-          showText={showText}
-        />
-        <PreviewDownloadButton
-          isCompiling={compilerState.isCompiling}
-          outputFiles={outputFiles}
-          pdfDownloadUrl={pdfDownloadUrl}
-          showText={showText}
-        />
-      </div>
-      <div className="toolbar-pdf-right">
-        <PreviewLogsToggleButton
-          logsState={logsState}
-          showLogs={showLogs}
-          autoCompileLintingError={
-            compilerState.isAutoCompileOn &&
-            compilerState.autoCompileHasLintingError
-          }
-          compileFailed={compilerState.compileFailed}
-          onToggle={onToggleLogs}
-          showText={showToggleText}
-        />
-        <OverlayTrigger placement="left" overlay={pdfExpandTooltip}>
-          <button
-            onClick={handlePdfExpandBtnClick}
-            className="toolbar-pdf-expand-btn toolbar-item"
-            aria-label={pdfExpandLabel}
-          >
-            <Icon type={pdfExpandIconType} />
-          </button>
-        </OverlayTrigger>
-      </div>
-    </div>
-  )
-}
-
-PreviewToolbar.propTypes = {
-  compilerState: PropTypes.shape({
-    autoCompileHasLintingError: PropTypes.bool,
-    isAutoCompileOn: PropTypes.bool.isRequired,
-    isCompiling: PropTypes.bool.isRequired,
-    isDraftModeOn: PropTypes.bool.isRequired,
-    isSyntaxCheckOn: PropTypes.bool.isRequired,
-    compileFailed: PropTypes.bool,
-    logEntries: PropTypes.object.isRequired,
-  }),
-  logsState: PropTypes.shape({
-    nErrors: PropTypes.number.isRequired,
-    nWarnings: PropTypes.number.isRequired,
-  }),
-  showLogs: PropTypes.bool.isRequired,
-  splitLayout: PropTypes.bool.isRequired,
-  onRecompile: PropTypes.func.isRequired,
-  onRecompileFromScratch: PropTypes.func.isRequired,
-  onRunSyntaxCheckNow: PropTypes.func.isRequired,
-  onSetAutoCompile: PropTypes.func.isRequired,
-  onSetDraftMode: PropTypes.func.isRequired,
-  onSetSyntaxCheck: PropTypes.func.isRequired,
-  onToggleLogs: PropTypes.func.isRequired,
-  onSetSplitLayout: PropTypes.func.isRequired,
-  onSetFullLayout: PropTypes.func.isRequired,
-  onStopCompilation: PropTypes.func.isRequired,
-  pdfDownloadUrl: PropTypes.string,
-  outputFiles: PropTypes.array,
-}
-
-export default PreviewToolbar

services/web/frontend/js/features/preview/components/preview-validation-issue.js

@@ -1,61 +0,0 @@
-import PropTypes from 'prop-types'
-import { useTranslation } from 'react-i18next'
-import PreviewLogsPaneEntry from './preview-logs-pane-entry'
-
-function PreviewValidationIssue({ name, details }) {
-  const { t } = useTranslation()
-  let validationTitle
-  let validationContent
-
-  if (name === 'sizeCheck') {
-    validationTitle = t('project_too_large')
-    validationContent = (
-      <>
-        <div>{t('project_too_large_please_reduce')}</div>
-        <ul className="list-no-margin-bottom">
-          {details.resources.map((resource, index) => (
-            <li key={index}>
-              {resource.path} &mdash; {resource.kbSize}
-              kb
-            </li>
-          ))}
-        </ul>
-      </>
-    )
-  } else if (name === 'conflictedPaths') {
-    validationTitle = t('conflicting_paths_found')
-    validationContent = (
-      <>
-        <div>{t('following_paths_conflict')}</div>
-        <ul className="list-no-margin-bottom">
-          {details.map((detail, index) => (
-            <li key={index}>/{detail.path}</li>
-          ))}
-        </ul>
-      </>
-    )
-  } else if (name === 'mainFile') {
-    validationTitle = t('main_file_not_found')
-    validationContent = <>{t('please_set_main_file')}</>
-  }
-
-  return validationTitle ? (
-    <PreviewLogsPaneEntry
-      headerTitle={validationTitle}
-      formattedContent={validationContent}
-      entryAriaLabel={t('validation_issue_entry_description')}
-      level="error"
-    />
-  ) : null
-}
-
-PreviewValidationIssue.propTypes = {
-  name: PropTypes.string.isRequired,
-  details: PropTypes.oneOfType([
-    PropTypes.object,
-    PropTypes.array,
-    PropTypes.bool,
-  ]),
-}
-
-export default PreviewValidationIssue

services/web/frontend/js/ide.js

@@ -25,17 +25,16 @@ import OnlineUsersManager from './ide/online-users/OnlineUsersManager'
 import HistoryManager from './ide/history/HistoryManager'
 import HistoryV2Manager from './ide/history/HistoryV2Manager'
 import PermissionsManager from './ide/permissions/PermissionsManager'
-import PdfManager from './ide/pdf/PdfManager'
 import BinaryFilesManager from './ide/binary-files/BinaryFilesManager'
 import ReferencesManager from './ide/references/ReferencesManager'
 import MetadataManager from './ide/metadata/MetadataManager'
-import ReviewPanelManager from './ide/review-panel/ReviewPanelManager'
+import './ide/review-panel/ReviewPanelManager'
 import OutlineManager from './features/outline/outline-manager'
 import SafariScrollPatcher from './ide/SafariScrollPatcher'
 import {
   loadServiceWorker,
   unregisterServiceWorker,
-} from './ide/pdfng/directives/serviceWorkerManager'
+} from './features/pdf-preview/util/service-worker'
 import './ide/cobranding/CobrandingDataService'
 import './ide/settings/index'
 import './ide/chat/index'
@@ -210,7 +209,6 @@ App.controller(
     } else {
       ide.historyManager = new HistoryManager(ide, $scope)
     }
-    ide.pdfManager = new PdfManager(ide, $scope)
     ide.permissionsManager = new PermissionsManager(ide, $scope)
     ide.binaryFilesManager = new BinaryFilesManager(ide, $scope)
     ide.metadataManager = new MetadataManager(ide, $scope, metadata)

services/web/frontend/js/ide/pdf/PdfManager.js

@@ -1,41 +0,0 @@
-/* eslint-disable
-    no-unused-vars,
-*/
-// TODO: This file was created by bulk-decaffeinate.
-// Fix any style issues and re-enable lint.
-/*
- * decaffeinate suggestions:
- * DS102: Remove unnecessary code created because of implicit returns
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-import './controllers/PdfController'
-import './controllers/PdfSynctexController'
-import '../pdfng/directives/pdfJs'
-
-let PdfManager
-
-export default PdfManager = class PdfManager {
-  constructor(ide, $scope) {
-    this.ide = ide
-    this.$scope = $scope
-    this.$scope.pdf = {
-      url: null, // Pdf Url
-      error: false, // Server error
-      timeout: false, // Server timed out
-      failure: false, // PDF failed to compile
-      compiling: false,
-      uncompiled: true,
-      logEntries: {},
-      logEntryAnnotations: {},
-      rawLog: '',
-      validation: {},
-      view: null, // 'pdf' 'logs'
-      showRawLog: false,
-      highlights: [],
-      position: null,
-      lastCompileTimestamp: null,
-      clsiServerId: null,
-      compileGroup: null,
-    }
-  }
-}

services/web/frontend/js/ide/pdf/controllers/PdfController.js

@@ -1,1000 +0,0 @@
-import App from '../../../base'
-import HumanReadableLogs from '../../human-readable-logs/HumanReadableLogs'
-import BibLogParser from '../../log-parser/bib-log-parser'
-import PreviewPane from '../../../features/preview/components/preview-pane'
-import { react2angular } from 'react2angular'
-import { rootContext } from '../../../shared/context/root-context'
-import 'ace/ace'
-import getMeta from '../../../utils/meta'
-import { trackPdfDownload } from './PdfJsMetrics'
-
-const AUTO_COMPILE_MAX_WAIT = 5000
-// We add a 1 second debounce to sending user changes to server if they aren't
-// collaborating with anyone. This needs to be higher than that, and allow for
-// client to server latency, otherwise we compile before the op reaches the server
-// and then again on ack.
-const AUTO_COMPILE_DEBOUNCE = 2000
-
-App.filter('trusted', $sce => url => $sce.trustAsResourceUrl(url))
-
-App.controller(
-  'PdfController',
-  function (
-    $scope,
-    $http,
-    ide,
-    $modal,
-    synctex,
-    eventTracking,
-    localStorage,
-    $q
-  ) {
-    let autoCompile = true
-
-    // pdf.view = uncompiled | pdf | errors
-    $scope.pdf.view = $scope.pdf.url ? 'pdf' : 'uncompiled'
-    $scope.pdf.clearingCache = false
-    $scope.shouldShowLogs = false
-
-    $scope.logsUIVariant = window.logsUIVariant
-
-    // view logic to check whether the files dropdown should "drop up" or "drop down"
-    $scope.shouldDropUp = false
-
-    // Exposed methods for React layout handling
-    $scope.setPdfSplitLayout = function () {
-      $scope.$applyAsync(() => $scope.switchToSideBySideLayout('editor'))
-    }
-    $scope.setPdfFullLayout = function () {
-      $scope.$applyAsync(() => $scope.switchToFlatLayout('pdf'))
-    }
-
-    const logsContainerEl = document.querySelector('.pdf-logs')
-    const filesDropdownEl =
-      logsContainerEl && logsContainerEl.querySelector('.files-dropdown')
-
-    // get the top coordinate of the files dropdown as a ratio (to the logs container height)
-    // logs container supports scrollable content, so it's possible that ratio > 1.
-    function getFilesDropdownTopCoordAsRatio() {
-      if (filesDropdownEl == null || logsContainerEl == null) {
-        return 0
-      }
-      return (
-        filesDropdownEl.getBoundingClientRect().top /
-        logsContainerEl.getBoundingClientRect().height
-      )
-    }
-
-    $scope.$watch('shouldShowLogs', shouldShow => {
-      if (shouldShow) {
-        $scope.$applyAsync(() => {
-          $scope.shouldDropUp = getFilesDropdownTopCoordAsRatio() > 0.65
-        })
-      }
-    })
-
-    $scope.trackLogHintsLearnMore = function () {
-      eventTracking.sendMB('logs-hints-learn-more')
-    }
-
-    if (ace.require('ace/lib/useragent').isMac) {
-      $scope.modifierKey = 'Cmd'
-    } else {
-      $scope.modifierKey = 'Ctrl'
-    }
-
-    // utility for making a query string from a hash, could use jquery $.param
-    function createQueryString(args) {
-      const qsArgs = []
-      for (const k in args) {
-        const v = args[k]
-        qsArgs.push(`${k}=${v}`)
-      }
-      if (qsArgs.length) {
-        return `?${qsArgs.join('&')}`
-      } else {
-        return ''
-      }
-    }
-
-    $scope.$on('project:joined', () => {
-      if (!autoCompile) {
-        return
-      }
-      autoCompile = false
-      $scope.recompile({ isAutoCompileOnLoad: true })
-      $scope.hasPremiumCompile =
-        $scope.project.features.compileGroup === 'priority'
-    })
-
-    $scope.$on('pdf:error:display', function () {
-      $scope.pdf.view = 'errors'
-      $scope.pdf.renderingError = true
-    })
-
-    let autoCompileInterval = null
-    function autoCompileIfReady() {
-      if (
-        $scope.pdf.compiling ||
-        !$scope.autocompile_enabled ||
-        !$scope.pdf.uncompiled
-      ) {
-        return
-      }
-
-      // Only checking linting if syntaxValidation is on and visible to the user
-      const autoCompileLintingError =
-        ide.$scope.hasLintingError && ide.$scope.settings.syntaxValidation
-      if ($scope.autoCompileLintingError !== autoCompileLintingError) {
-        $scope.$apply(() => {
-          $scope.autoCompileLintingError = autoCompileLintingError
-          // We've likely been waiting a while until the user fixed the linting, but we
-          // don't want to compile as soon as it is fixed, so reset the timeout.
-          $scope.startedTryingAutoCompileAt = Date.now()
-          $scope.docLastChangedAt = Date.now()
-        })
-      }
-      if (autoCompileLintingError && $scope.stop_on_validation_error) {
-        return
-      }
-
-      // If there's a longish compile, don't compile immediately after if user is still typing
-      const startedTryingAt = Math.max(
-        $scope.startedTryingAutoCompileAt,
-        $scope.lastFinishedCompileAt || 0
-      )
-
-      const timeSinceStartedTrying = Date.now() - startedTryingAt
-      const timeSinceLastChange = Date.now() - $scope.docLastChangedAt
-
-      let shouldCompile = false
-      if (timeSinceLastChange > AUTO_COMPILE_DEBOUNCE) {
-        // Don't compile in the middle of the user typing
-        shouldCompile = true
-      } else if (timeSinceStartedTrying > AUTO_COMPILE_MAX_WAIT) {
-        // Unless they type for a long time
-        shouldCompile = true
-      } else if (timeSinceStartedTrying < 0 || timeSinceLastChange < 0) {
-        // If time is non-monotonic, assume that the user's system clock has been
-        // changed and continue with compile
-        shouldCompile = true
-      }
-
-      if (shouldCompile) {
-        return triggerAutoCompile()
-      }
-    }
-
-    function triggerAutoCompile() {
-      $scope.recompile({ isAutoCompileOnChange: true })
-    }
-
-    function startTryingAutoCompile() {
-      if (autoCompileInterval != null) {
-        return
-      }
-      $scope.startedTryingAutoCompileAt = Date.now()
-      autoCompileInterval = setInterval(autoCompileIfReady, 200)
-    }
-
-    function stopTryingAutoCompile() {
-      clearInterval(autoCompileInterval)
-      autoCompileInterval = null
-    }
-
-    $scope.changesToAutoCompile = false
-    $scope.$watch('pdf.uncompiled', uncompiledChanges => {
-      // don't autocompile if disabled or the pdf is not visible
-      if (
-        $scope.pdf.uncompiled &&
-        $scope.autocompile_enabled &&
-        !$scope.ui.pdfHidden
-      ) {
-        $scope.changesToAutoCompile = true
-        startTryingAutoCompile()
-      } else {
-        $scope.changesToAutoCompile = false
-        stopTryingAutoCompile()
-      }
-    })
-
-    function recalculateUncompiledChanges() {
-      if ($scope.docLastChangedAt == null) {
-        $scope.pdf.uncompiled = false
-      } else if (
-        $scope.lastStartedCompileAt == null ||
-        $scope.docLastChangedAt > $scope.lastStartedCompileAt
-      ) {
-        $scope.pdf.uncompiled = true
-      } else {
-        $scope.pdf.uncompiled = false
-      }
-    }
-
-    function _updateDocLastChangedAt() {
-      $scope.docLastChangedAt = Date.now()
-      recalculateUncompiledChanges()
-    }
-
-    function onDocChanged() {
-      _updateDocLastChangedAt()
-    }
-
-    function onDocSaved() {
-      // We use the save as a trigger too, to account for the delay between the client
-      // and server. Otherwise, we might have compiled after the user made
-      // the change on the client, but before the server had it.
-      _updateDocLastChangedAt()
-    }
-
-    function onCompilingStateChanged(compiling) {
-      recalculateUncompiledChanges()
-    }
-
-    ide.$scope.$on('doc:changed', onDocChanged)
-    ide.$scope.$on('doc:saved', onDocSaved)
-    $scope.$watch('pdf.compiling', onCompilingStateChanged)
-
-    $scope.autocompile_enabled =
-      localStorage(`autocompile_enabled:${$scope.project_id}`) || false
-    $scope.$watch('autocompile_enabled', (newValue, oldValue) => {
-      if (newValue != null && oldValue !== newValue) {
-        if (newValue === true) {
-          $scope.autoCompileLintingError = false
-          autoCompileIfReady()
-        }
-        localStorage(`autocompile_enabled:${$scope.project_id}`, newValue)
-      }
-    })
-
-    // abort compile if syntax checks fail
-    $scope.stop_on_validation_error = localStorage(
-      `stop_on_validation_error:${$scope.project_id}`
-    )
-    if ($scope.stop_on_validation_error == null) {
-      $scope.stop_on_validation_error = true
-    }
-    // turn on for all users by default
-    $scope.$watch('stop_on_validation_error', (newValue, oldValue) => {
-      if (newValue != null && oldValue !== newValue) {
-        localStorage(`stop_on_validation_error:${$scope.project_id}`, newValue)
-      }
-    })
-
-    $scope.draft = localStorage(`draft:${$scope.project_id}`) || false
-    $scope.$watch('draft', (newValue, oldValue) => {
-      if (newValue != null && oldValue !== newValue) {
-        localStorage(`draft:${$scope.project_id}`, newValue)
-      }
-    })
-
-    function sendCompileRequest(options) {
-      if (options == null) {
-        options = {}
-      }
-      const url = `/project/${$scope.project_id}/compile`
-      const params = {}
-      if (options.isAutoCompileOnLoad || options.isAutoCompileOnChange) {
-        params.auto_compile = true
-      }
-      if (getMeta('ol-enablePdfCaching')) {
-        params.enable_pdf_caching = true
-      }
-      if (window.location.search.includes('file_line_errors=true')) {
-        params.file_line_errors = 'true'
-      }
-      // if the previous run was a check, clear the error logs
-      if ($scope.check) {
-        $scope.pdf.logEntries = {}
-      }
-      // keep track of whether this is a compile or check
-      $scope.check = !!options.check
-      if (options.check) {
-        eventTracking.sendMB('syntax-check-request')
-      }
-      // send appropriate check type to clsi
-      let checkType
-      if ($scope.check) {
-        checkType = 'validate' // validate only
-      } else if (options.try) {
-        checkType = 'silent' // allow use to try compile once
-      } else if ($scope.stop_on_validation_error) {
-        checkType = 'error' // try to compile
-      } else {
-        checkType = 'silent' // ignore errors
-      }
-
-      // FIXME: Temporarily disable syntax checking as it is causing
-      // excessive support requests for projects migrated from v1
-      // https://github.com/overleaf/sharelatex/issues/911
-      if (checkType === 'error') {
-        checkType = 'silent'
-      }
-
-      return $http.post(
-        url,
-        {
-          rootDoc_id: options.rootDocOverride_id || null,
-          draft: $scope.draft,
-          check: checkType,
-          // use incremental compile for all users but revert to a full
-          // compile if there is a server error
-          incrementalCompilesEnabled: !$scope.pdf.error,
-          _csrf: window.csrfToken,
-        },
-        { params }
-      )
-    }
-
-    function buildPdfDownloadUrl(pdfDownloadDomain, url) {
-      if (pdfDownloadDomain) {
-        return `${pdfDownloadDomain}${url}`
-      } else {
-        return url
-      }
-    }
-
-    function noop() {}
-
-    function parseCompileResponse(response, compileTimeClientE2E) {
-      // keep last url
-      const lastPdfUrl = $scope.pdf.url
-      const { pdfDownloadDomain } = response
-      // Reset everything
-      $scope.pdf.error = false
-      $scope.pdf.timedout = false
-      $scope.pdf.failure = false
-      $scope.pdf.url = null
-      $scope.pdf.updateConsumedBandwidth = noop
-      $scope.pdf.firstRenderDone = noop
-      $scope.pdf.clsiMaintenance = false
-      $scope.pdf.clsiUnavailable = false
-      $scope.pdf.tooRecentlyCompiled = false
-      $scope.pdf.renderingError = false
-      $scope.pdf.projectTooLarge = false
-      $scope.pdf.compileTerminated = false
-      $scope.pdf.compileExited = false
-      $scope.pdf.failedCheck = false
-      $scope.pdf.compileInProgress = false
-      $scope.pdf.autoCompileDisabled = false
-      $scope.pdf.compileFailed = false
-
-      // make a cache to look up files by name
-      const fileByPath = {}
-      if (response.outputFiles != null) {
-        for (const file of response.outputFiles) {
-          fileByPath[file.path] = file
-        }
-      }
-
-      // prepare query string
-      let qs = {}
-      // add a query string parameter for the compile group
-      if (response.compileGroup != null) {
-        $scope.pdf.compileGroup = qs.compileGroup = response.compileGroup
-      }
-      // add a query string parameter for the clsi server id
-      if (response.clsiServerId != null) {
-        $scope.pdf.clsiServerId = qs.clsiserverid = response.clsiServerId
-      }
-
-      // TODO(das7pad): drop this hack once 2747f0d40af8729304 has landed in clsi
-      if (response.status === 'success' && !fileByPath['output.pdf']) {
-        response.status = 'failure'
-      }
-
-      if (response.status === 'success') {
-        $scope.pdf.view = 'pdf'
-        $scope.shouldShowLogs = false
-        $scope.pdf.lastCompileTimestamp = Date.now()
-        $scope.pdf.validation = {}
-        $scope.pdf.url = buildPdfDownloadUrl(
-          pdfDownloadDomain,
-          fileByPath['output.pdf'].url
-        )
-
-        if (window.location.search.includes('verify_chunks=true')) {
-          // Instruct the serviceWorker to verify composed ranges.
-          qs.verify_chunks = 'true'
-        }
-        if (getMeta('ol-enablePdfCaching')) {
-          // Tag traffic that uses the pdf caching logic.
-          qs.enable_pdf_caching = 'true'
-        }
-
-        // convert the qs hash into a query string and append it
-        $scope.pdf.url += createQueryString(qs)
-
-        if (getMeta('ol-trackPdfDownload')) {
-          const { firstRenderDone, updateConsumedBandwidth } = trackPdfDownload(
-            response,
-            compileTimeClientE2E
-          )
-          $scope.pdf.firstRenderDone = firstRenderDone
-          $scope.pdf.updateConsumedBandwidth = updateConsumedBandwidth
-        }
-
-        // Save all downloads as files
-        qs.popupDownload = true
-
-        const { build: buildId } = fileByPath['output.pdf']
-        $scope.pdf.downloadUrl =
-          `/download/project/${$scope.project_id}/build/${buildId}/output/output.pdf` +
-          createQueryString(qs)
-        fetchLogs(fileByPath, { pdfDownloadDomain })
-      } else if (response.status === 'timedout') {
-        $scope.pdf.view = 'errors'
-        $scope.pdf.timedout = true
-        fetchLogs(fileByPath, { pdfDownloadDomain })
-        if (
-          !$scope.hasPremiumCompile &&
-          ide.$scope.project.owner._id === ide.$scope.user.id
-        ) {
-          eventTracking.send(
-            'subscription-funnel',
-            'editor-click-feature',
-            'compile-timeout'
-          )
-          eventTracking.sendMB('paywall-prompt', {
-            'paywall-type': 'compile-timeout',
-          })
-        }
-      } else if (response.status === 'terminated') {
-        $scope.pdf.view = 'errors'
-        $scope.pdf.compileTerminated = true
-        fetchLogs(fileByPath, { pdfDownloadDomain })
-      } else if (
-        ['validation-fail', 'validation-pass'].includes(response.status)
-      ) {
-        $scope.pdf.view = 'pdf'
-        $scope.pdf.url = lastPdfUrl
-        $scope.shouldShowLogs = true
-        if (response.status === 'validation-fail') {
-          $scope.pdf.failedCheck = true
-        }
-        eventTracking.sendMB(`syntax-check-${response.status}`)
-        fetchLogs(fileByPath, { validation: true, pdfDownloadDomain })
-      } else if (response.status === 'exited') {
-        $scope.pdf.view = 'pdf'
-        $scope.pdf.compileExited = true
-        $scope.pdf.url = lastPdfUrl
-        $scope.shouldShowLogs = true
-        fetchLogs(fileByPath, { pdfDownloadDomain })
-      } else if (response.status === 'autocompile-backoff') {
-        if ($scope.pdf.isAutoCompileOnLoad) {
-          // initial autocompile
-          $scope.pdf.view = 'uncompiled'
-        } else {
-          // background autocompile from typing
-          $scope.pdf.view = 'errors'
-          $scope.pdf.autoCompileDisabled = true
-          $scope.autocompile_enabled = false // disable any further autocompiles
-        }
-      } else if (response.status === 'project-too-large') {
-        $scope.pdf.view = 'errors'
-        $scope.pdf.projectTooLarge = true
-      } else if (response.status === 'failure') {
-        $scope.pdf.view = 'errors'
-        $scope.pdf.failure = true
-        $scope.pdf.downloadUrl = null
-        $scope.shouldShowLogs = true
-        fetchLogs(fileByPath, { pdfDownloadDomain })
-      } else if (response.status === 'clsi-maintenance') {
-        $scope.pdf.view = 'errors'
-        $scope.pdf.clsiMaintenance = true
-      } else if (response.status === 'unavailable') {
-        $scope.pdf.view = 'errors'
-        $scope.pdf.clsiUnavailable = true
-      } else if (response.status === 'too-recently-compiled') {
-        $scope.pdf.view = 'errors'
-        $scope.pdf.tooRecentlyCompiled = true
-      } else if (response.status === 'validation-problems') {
-        $scope.pdf.view = 'validation-problems'
-        $scope.pdf.validation = response.validationProblems
-        $scope.shouldShowLogs = false
-      } else if (response.status === 'compile-in-progress') {
-        $scope.pdf.view = 'errors'
-        $scope.pdf.compileInProgress = true
-      } else {
-        // fall back to displaying an error
-        $scope.pdf.view = 'errors'
-        $scope.pdf.error = true
-      }
-
-      const IGNORE_FILES = ['output.fls', 'output.fdb_latexmk']
-      $scope.pdf.outputFiles = []
-
-      if (response.outputFiles == null) {
-        return
-      }
-
-      // prepare list of output files for download dropdown
-      qs = {}
-      if (response.clsiServerId != null) {
-        qs.clsiserverid = response.clsiServerId
-      }
-      for (const file of response.outputFiles) {
-        if (IGNORE_FILES.indexOf(file.path) === -1) {
-          const isOutputFile = /^output\./.test(file.path)
-          $scope.pdf.outputFiles.push({
-            // Turn 'output.blg' into 'blg file'.
-            name: isOutputFile
-              ? `${file.path.replace(/^output\./, '')} file`
-              : file.path,
-            url: file.url + createQueryString(qs),
-            main: !!isOutputFile,
-            fileName: file.path,
-            type: file.type,
-          })
-        }
-      }
-
-      // sort the output files into order, main files first, then others
-      $scope.pdf.outputFiles.sort(
-        (a, b) => b.main - a.main || a.name.localeCompare(b.name)
-      )
-    }
-
-    // In the existing compile UI, errors and validation problems are shown in the PDF pane, whereas in the new
-    // one they're shown in the logs pane. This `$watch`er makes sure we change the view in the new logs UI.
-    // This should be removed once we stop supporting the two different log UIs.
-    if (window.logsUIVariant !== 'default') {
-      $scope.$watch(
-        () =>
-          $scope.pdf.view === 'errors' ||
-          $scope.pdf.view === 'validation-problems',
-        newVal => {
-          if (newVal) {
-            $scope.shouldShowLogs = true
-            $scope.pdf.compileFailed = true
-          }
-        }
-      )
-    }
-
-    function fetchLogs(fileByPath, options) {
-      let blgFile, chktexFile, logFile
-
-      if (options != null ? options.validation : undefined) {
-        chktexFile = fileByPath['output.chktex']
-      } else {
-        logFile = fileByPath['output.log']
-        blgFile = fileByPath['output.blg']
-      }
-
-      function getFile(name, file) {
-        const opts = {
-          method: 'GET',
-          url: buildPdfDownloadUrl(options.pdfDownloadDomain, file.url),
-          params: {
-            compileGroup: $scope.pdf.compileGroup,
-            clsiserverid: $scope.pdf.clsiServerId,
-          },
-        }
-        return $http(opts)
-      }
-
-      // accumulate the log entries
-      const logEntries = {
-        all: [],
-        errors: [],
-        warnings: [],
-        typesetting: [],
-      }
-
-      function accumulateResults(newEntries) {
-        for (const key of ['all', 'errors', 'warnings', 'typesetting']) {
-          if (newEntries[key]) {
-            if (newEntries.type != null) {
-              for (const entry of newEntries[key]) {
-                entry.type = newEntries.type
-              }
-            }
-            logEntries[key] = logEntries[key].concat(newEntries[key])
-          }
-        }
-      }
-
-      // use the parsers for each file type
-      function processLog(log) {
-        $scope.pdf.rawLog = log
-        const { errors, warnings, typesetting } = HumanReadableLogs.parse(log, {
-          ignoreDuplicates: true,
-        })
-        const all = [].concat(errors, warnings, typesetting)
-        accumulateResults({ all, errors, warnings, typesetting })
-      }
-
-      function processChkTex(log) {
-        const errors = []
-        const warnings = []
-        for (const line of log.split('\n')) {
-          let m
-          if ((m = line.match(/^(\S+):(\d+):(\d+): (Error|Warning): (.*)/))) {
-            const result = {
-              file: m[1],
-              line: m[2],
-              column: m[3],
-              level: m[4].toLowerCase(),
-              message: `${m[4]}: ${m[5]}`,
-            }
-            if (result.level === 'error') {
-              errors.push(result)
-            } else {
-              warnings.push(result)
-            }
-          }
-        }
-        const all = [].concat(errors, warnings)
-        const logHints = HumanReadableLogs.parse({
-          type: 'Syntax',
-          all,
-          errors,
-          warnings,
-        })
-        eventTracking.sendMB('syntax-check-return-count', {
-          errors: errors.length,
-          warnings: warnings.length,
-        })
-        accumulateResults(logHints)
-      }
-
-      function processBiber(log) {
-        const bibLogParser = new BibLogParser(log, {
-          maxErrors: 100,
-          buildMaxErrorsReachedMessage: true,
-        })
-        const { errors, warnings } = bibLogParser.parse(log, {})
-        const all = [].concat(errors, warnings)
-        accumulateResults({ type: 'BibTeX:', all, errors, warnings })
-      }
-
-      // output the results
-      function handleError() {
-        $scope.pdf.logEntries = {}
-        $scope.pdf.rawLog = ''
-      }
-
-      function annotateFiles() {
-        $scope.pdf.logEntries = logEntries
-        $scope.pdf.logEntryAnnotations = {}
-        for (const entry of logEntries.all) {
-          if (entry.file != null) {
-            entry.file = normalizeFilePath(entry.file)
-            const entity = ide.fileTreeManager.findEntityByPath(entry.file)
-            if (entity != null) {
-              if (!$scope.pdf.logEntryAnnotations[entity.id]) {
-                $scope.pdf.logEntryAnnotations[entity.id] = []
-              }
-              $scope.pdf.logEntryAnnotations[entity.id].push({
-                row: entry.line - 1,
-                type: entry.level === 'error' ? 'error' : 'warning',
-                text: entry.message,
-              })
-            }
-          }
-        }
-      }
-
-      // retrieve the logfile and process it
-      let response
-      if (logFile != null) {
-        response = getFile('output.log', logFile).then(response =>
-          processLog(response.data)
-        )
-
-        if (blgFile != null) {
-          // retrieve the blg file if present
-          response = response.then(() =>
-            getFile('output.blg', blgFile).then(
-              response => processBiber(response.data),
-              () => true
-            )
-          )
-        }
-      }
-
-      if (response != null) {
-        response.catch(handleError)
-      } else {
-        handleError()
-      }
-
-      if (chktexFile != null) {
-        const getChkTex = () =>
-          getFile('output.chktex', chktexFile).then(response =>
-            processChkTex(response.data)
-          )
-        // always retrieve the chktex file if present
-        if (response != null) {
-          response = response.then(getChkTex, getChkTex)
-        } else {
-          response = getChkTex()
-        }
-      }
-
-      // display the combined result
-      if (response != null) {
-        response.finally(() => {
-          annotateFiles()
-          sendCompileMetrics()
-        })
-      }
-    }
-
-    function sendCompileMetrics() {
-      const hasCompiled =
-        $scope.pdf.view !== 'errors' &&
-        $scope.pdf.view !== 'validation-problems'
-
-      if (hasCompiled && !window.user.alphaProgram) {
-        const metadata = {
-          errors: $scope.pdf.logEntries.errors.length,
-          warnings: $scope.pdf.logEntries.warnings.length,
-          typesetting: $scope.pdf.logEntries.typesetting.length,
-          logsUIVariant: window.logsUIVariant,
-        }
-        eventTracking.sendMBSampled('compile-result', metadata, 0.01)
-      }
-    }
-
-    function getRootDocOverrideId() {
-      const rootDocId = $scope.project.rootDoc_id
-      const currentDocId = ide.editorManager.getCurrentDocId()
-      if (currentDocId === rootDocId) {
-        return null // no need to override when in the root doc itself
-      }
-      const doc = ide.editorManager.getCurrentDocValue()
-      if (doc == null) {
-        return null
-      }
-      for (const line of doc.split('\n')) {
-        if (/^[^%]*\\documentclass/.test(line)) {
-          return ide.editorManager.getCurrentDocId()
-        }
-      }
-      return null
-    }
-
-    function normalizeFilePath(path) {
-      path = path.replace(
-        /^(.*)\/compiles\/[0-9a-f]{24}(-[0-9a-f]{24})?\/(\.\/)?/,
-        ''
-      )
-      path = path.replace(/^\/compile\//, '')
-
-      const rootDocDirname = ide.fileTreeManager.getRootDocDirname()
-      if (rootDocDirname) {
-        path = path.replace(/^\.\//, rootDocDirname + '/')
-      } else {
-        path = path.replace(/^\.\//, '')
-      }
-
-      return path
-    }
-
-    $scope.recompile = function (options) {
-      if (options == null) {
-        options = {}
-      }
-      if ($scope.pdf.compiling) {
-        return
-      }
-
-      $scope.lastStartedCompileAt = Date.now()
-      $scope.pdf.compiling = true
-      $scope.pdf.isAutoCompileOnLoad =
-        options != null ? options.isAutoCompileOnLoad : undefined // initial autocompile
-
-      if (options != null ? options.force : undefined) {
-        // for forced compile, turn off validation check and ignore errors
-        $scope.stop_on_validation_error = false
-        $scope.shouldShowLogs = false // hide the logs while compiling
-        eventTracking.sendMB('syntax-check-turn-off-checking')
-      }
-
-      if (options != null ? options.try : undefined) {
-        $scope.shouldShowLogs = false // hide the logs while compiling
-        eventTracking.sendMB('syntax-check-try-compile-anyway')
-      }
-
-      ide.$scope.$broadcast('flush-changes')
-
-      options.rootDocOverride_id = getRootDocOverrideId()
-
-      const t0 = performance.now()
-      sendCompileRequest(options)
-        .then(function (response) {
-          const { data } = response
-          const compileTimeClientE2E = performance.now() - t0
-          $scope.pdf.view = 'pdf'
-          $scope.pdf.compiling = false
-          parseCompileResponse(data, compileTimeClientE2E)
-        })
-        .catch(function (response) {
-          const { status } = response
-          if (status === 429) {
-            $scope.pdf.rateLimited = true
-          }
-          $scope.pdf.compiling = false
-          $scope.pdf.renderingError = false
-          $scope.pdf.error = true
-          $scope.pdf.view = 'errors'
-        })
-        .finally(() => {
-          $scope.lastFinishedCompileAt = Date.now()
-        })
-    }
-
-    // This needs to be public.
-    ide.$scope.recompile = $scope.recompile
-
-    $scope.stop = function () {
-      if (!$scope.pdf.compiling) {
-        return
-      }
-
-      return $http({
-        url: `/project/${$scope.project_id}/compile/stop`,
-        method: 'POST',
-        params: {
-          clsiserverid: $scope.pdf.clsiServerId,
-        },
-        headers: {
-          'X-Csrf-Token': window.csrfToken,
-        },
-      })
-    }
-
-    $scope.clearCache = function () {
-      $scope.pdf.clearingCache = true
-      const deferred = $q.defer()
-
-      // disable various download buttons
-      $scope.pdf.url = null
-      $scope.pdf.downloadUrl = null
-      $scope.pdf.outputFiles = []
-
-      $http({
-        url: `/project/${$scope.project_id}/output`,
-        method: 'DELETE',
-        params: {
-          clsiserverid: $scope.pdf.clsiServerId,
-        },
-        headers: {
-          'X-Csrf-Token': window.csrfToken,
-        },
-      })
-        .then(function (response) {
-          $scope.pdf.clearingCache = false
-          return deferred.resolve()
-        })
-        .catch(function (response) {
-          console.error(response)
-          const error = response.data
-          $scope.pdf.clearingCache = false
-          $scope.pdf.renderingError = false
-          $scope.pdf.error = true
-          $scope.pdf.view = 'errors'
-          return deferred.reject(error)
-        })
-      return deferred.promise
-    }
-
-    $scope.recompileFromScratch = function () {
-      $scope.pdf.compiling = true
-      return $scope
-        .clearCache()
-        .then(() => {
-          $scope.pdf.compiling = false
-          $scope.recompile()
-        })
-        .catch(error => {
-          console.error(error)
-        })
-    }
-
-    $scope.toggleLogs = function () {
-      $scope.$applyAsync(() => {
-        $scope.shouldShowLogs = !$scope.shouldShowLogs
-        if ($scope.shouldShowLogs) {
-          eventTracking.sendMBOnce('ide-open-logs-once')
-        }
-      })
-    }
-
-    $scope.showPdf = function () {
-      $scope.pdf.view = 'pdf'
-      $scope.shouldShowLogs = false
-    }
-
-    $scope.toggleRawLog = function () {
-      $scope.pdf.showRawLog = !$scope.pdf.showRawLog
-      if ($scope.pdf.showRawLog) {
-        eventTracking.sendMB('logs-view-raw')
-      }
-    }
-
-    $scope.openClearCacheModal = function () {
-      $modal.open({
-        templateUrl: 'clearCacheModalTemplate',
-        controller: 'ClearCacheModalController',
-        scope: $scope,
-      })
-    }
-
-    $scope.syncToCode = function (position) {
-      synctex.syncToCode(position).then(function (data) {
-        const { doc, line } = data
-        ide.editorManager.openDoc(doc, { gotoLine: line })
-      })
-    }
-
-    $scope.setAutoCompile = function (isOn) {
-      $scope.$applyAsync(function () {
-        $scope.autocompile_enabled = isOn
-      })
-    }
-    $scope.setDraftMode = function (isOn) {
-      $scope.$applyAsync(function () {
-        $scope.draft = isOn
-      })
-    }
-    $scope.setSyntaxCheck = function (isOn) {
-      $scope.$applyAsync(function () {
-        $scope.stop_on_validation_error = isOn
-      })
-    }
-    $scope.runSyntaxCheckNow = function () {
-      $scope.$applyAsync(function () {
-        $scope.recompile({ check: true })
-      })
-    }
-
-    $scope.openInEditor = function (entry) {
-      let column, line
-      const entity = ide.fileTreeManager.findEntityByPath(entry.file)
-      if (entity == null || entity.type !== 'doc') {
-        return
-      }
-      if (entry.line != null) {
-        line = entry.line
-      }
-      if (entry.column != null) {
-        column = entry.column
-      }
-      ide.editorManager.openDoc(entity, {
-        gotoLine: line,
-        gotoColumn: column,
-      })
-    }
-  }
-)
-
-App.controller('ClearCacheModalController', function ($scope, $modalInstance) {
-  $scope.state = { error: false, inflight: false }
-
-  $scope.clear = function () {
-    $scope.state.inflight = true
-    $scope
-      .clearCache()
-      .then(function () {
-        $scope.state.inflight = false
-        $modalInstance.close()
-      })
-      .catch(function () {
-        $scope.state.error = true
-        $scope.state.inflight = false
-      })
-  }
-
-  $scope.cancel = () => $modalInstance.dismiss('cancel')
-})
-// Wrap React component as Angular component. Only needed for "top-level" component
-App.component(
-  'previewPane',
-  react2angular(
-    rootContext.use(PreviewPane),
-    Object.keys(PreviewPane.propTypes)
-  )
-)

services/web/frontend/js/ide/pdf/controllers/PdfSynctexController.js

@@ -1,202 +0,0 @@
-import App from '../../../base'
-
-App.controller('PdfSynctexController', function ($scope, synctex, ide) {
-  this.cursorPosition = null
-
-  $scope.$watch(
-    () => synctex.syncToPdfInFlight,
-    value => ($scope.syncToPdfInFlight = value)
-  )
-  $scope.$watch(
-    () => synctex.syncToCodeInFlight,
-    value => ($scope.syncToCodeInFlight = value)
-  )
-
-  ide.$scope.$on('cursor:editor:update', (event, cursorPosition) => {
-    this.cursorPosition = cursorPosition
-  })
-
-  $scope.syncToPdf = () => {
-    if (this.cursorPosition == null) {
-      return
-    }
-    synctex.syncToPdf(this.cursorPosition).then(highlights => {
-      $scope.pdf.highlights = highlights
-    })
-  }
-
-  ide.$scope.$on('cursor:editor:syncToPdf', $scope.syncToPdf)
-
-  function syncToPosition(position, options) {
-    synctex.syncToCode(position, options).then(data => {
-      ide.editorManager.openDoc(data.doc, {
-        gotoLine: data.line,
-      })
-    })
-  }
-
-  $scope.syncToCode = function () {
-    syncToPosition($scope.pdf.position, {
-      includeVisualOffset: true,
-      fromPdfPosition: true,
-    })
-  }
-
-  window.addEventListener('synctex:sync-to-position', event => {
-    syncToPosition(event.detail, {
-      fromPdfPosition: true,
-    })
-  })
-
-  window.addEventListener('synctex:sync-to-entry', event => {
-    const entry = event.detail
-
-    const entity = ide.fileTreeManager.findEntityByPath(entry.file)
-
-    if (entity && entity.type === 'doc') {
-      ide.editorManager.openDoc(entity, {
-        gotoLine: entry.line ?? undefined,
-        gotoColumn: entry.column ?? undefined,
-      })
-    }
-  })
-})
-
-App.factory('synctex', function (ide, $http, $q) {
-  return {
-    syncToPdfInFlight: false,
-    syncToCodeInFlight: false,
-
-    syncToPdf(cursorPosition) {
-      const deferred = $q.defer()
-
-      const docId = ide.editorManager.getCurrentDocId()
-      if (docId == null) {
-        deferred.reject()
-        return deferred.promise
-      }
-      const doc = ide.fileTreeManager.findEntityById(docId)
-      if (doc == null) {
-        deferred.reject()
-        return deferred.promise
-      }
-      let path = ide.fileTreeManager.getEntityPath(doc)
-      if (path == null) {
-        deferred.reject()
-        return deferred.promise
-      }
-
-      // If the root file is folder/main.tex, then synctex sees the
-      // path as folder/./main.tex
-      const rootDocDirname = ide.fileTreeManager.getRootDocDirname()
-      if (rootDocDirname != null && rootDocDirname !== '') {
-        path = path.replace(RegExp(`^${rootDocDirname}`), `${rootDocDirname}/.`)
-      }
-
-      const { row, column } = cursorPosition
-
-      this.syncToPdfInFlight = true
-
-      $http({
-        url: `/project/${ide.project_id}/sync/code`,
-        method: 'GET',
-        params: {
-          file: path,
-          line: row + 1,
-          column,
-          clsiserverid: ide.$scope.pdf.clsiServerId,
-        },
-      })
-        .then(response => {
-          this.syncToPdfInFlight = false
-          const { data } = response
-          return deferred.resolve(data.pdf || [])
-        })
-        .catch(response => {
-          this.syncToPdfInFlight = false
-          const error = response.data
-          return deferred.reject(error)
-        })
-
-      return deferred.promise
-    },
-
-    syncToCode(position, options) {
-      if (options == null) {
-        options = {}
-      }
-      const deferred = $q.defer()
-      if (position == null) {
-        deferred.reject()
-        return deferred.promise
-      }
-
-      // FIXME: this actually works better if it's halfway across the
-      // page (or the visible part of the page). Synctex doesn't
-      // always find the right place in the file when the point is at
-      // the edge of the page, it sometimes returns the start of the
-      // next paragraph instead.
-      const h = position.offset.left
-
-      // Compute the vertical position to pass to synctex, which
-      // works with coordinates increasing from the top of the page
-      // down.  This matches the browser's DOM coordinate of the
-      // click point, but the pdf position is measured from the
-      // bottom of the page so we need to invert it.
-      let v
-      if (
-        options.fromPdfPosition &&
-        (position.pageSize != null ? position.pageSize.height : undefined) !=
-          null
-      ) {
-        v = position.pageSize.height - position.offset.top || 0 // measure from pdf point (inverted)
-      } else {
-        v = position.offset.top || 0 // measure from html click position
-      }
-
-      // It's not clear exactly where we should sync to if it wasn't directly
-      // clicked on, but a little bit down from the very top seems best.
-      if (options.includeVisualOffset) {
-        v += 72 // use the same value as in pdfViewer highlighting visual offset
-      }
-
-      this.syncToCodeInFlight = true
-
-      $http({
-        url: `/project/${ide.project_id}/sync/pdf`,
-        method: 'GET',
-        params: {
-          page: position.page + 1,
-          h: h.toFixed(2),
-          v: v.toFixed(2),
-          clsiserverid: ide.$scope.pdf.clsiServerId,
-        },
-      })
-        .then(response => {
-          this.syncToCodeInFlight = false
-          const { data } = response
-          if (
-            data.code != null &&
-            data.code.length > 0 &&
-            data.code[0].file !== ''
-          ) {
-            const doc = ide.fileTreeManager.findEntityByPath(data.code[0].file)
-            if (doc == null) {
-              deferred.reject()
-            }
-            return deferred.resolve({ doc, line: data.code[0].line })
-          } else if (data.code[0].file === '') {
-            ide.$scope.sync_tex_error = true
-            setTimeout(() => (ide.$scope.sync_tex_error = false), 4000)
-          }
-        })
-        .catch(response => {
-          this.syncToCodeInFlight = false
-          const error = response.data
-          return deferred.reject(error)
-        })
-
-      return deferred.promise
-    },
-  }
-})

services/web/frontend/js/ide/pdfng/directives/pdfAnnotations.js

@@ -1,61 +0,0 @@
-import App from '../../../base'
-import PDFJS from './pdfJsLoader'
-const EXTERNAL_LINK_TARGET = '_blank'
-const REL_NOOPENER = 'noreferrer noopener'
-
-App.factory('pdfAnnotations', function () {
-  class pdfAnnotations {
-    constructor(options) {
-      this.annotationsLayerDiv = options.annotations
-      this.viewport = options.viewport
-      this.navigateFn = options.navigateFn
-    }
-
-    setAnnotations(annotations) {
-      const result = []
-      for (const annotation of annotations) {
-        switch (annotation.subtype) {
-          case 'Link':
-            result.push(this.addLink(annotation))
-            break
-          case 'Text':
-            continue
-          default:
-            result.push(undefined)
-        }
-      }
-    }
-
-    addLink(link) {
-      const element = this.buildLinkElementFromRect(link.rect)
-      this.setLinkTarget(element, link)
-      this.annotationsLayerDiv.appendChild(element)
-    }
-
-    buildLinkElementFromRect(rect) {
-      rect = this.viewport.convertToViewportRectangle(rect)
-      rect = PDFJS.Util.normalizeRect(rect)
-      const element = document.createElement('a')
-      element.style.left = Math.floor(rect[0]) + 'px'
-      element.style.top = Math.floor(rect[1]) + 'px'
-      element.style.width = Math.ceil(rect[2] - rect[0]) + 'px'
-      element.style.height = Math.ceil(rect[3] - rect[1]) + 'px'
-      return element
-    }
-
-    setLinkTarget(element, link) {
-      if (link.url) {
-        element.href = link.url
-        element.target = EXTERNAL_LINK_TARGET
-        element.rel = REL_NOOPENER
-      } else if (link.dest) {
-        element.href = `#${link.dest}`
-        element.onclick = () => {
-          this.navigateFn(link)
-          return false
-        }
-      }
-    }
-  }
-  return pdfAnnotations
-})

services/web/frontend/js/ide/pdfng/directives/pdfHighlights.js

@@ -1,53 +0,0 @@
-/* eslint-disable
-    max-len,
-    no-return-assign,
-    no-unused-vars,
-*/
-// TODO: This file was created by bulk-decaffeinate.
-// Fix any style issues and re-enable lint.
-/*
- * decaffeinate suggestions:
- * DS101: Remove unnecessary use of Array.from
- * DS102: Remove unnecessary code created because of implicit returns
- * DS207: Consider shorter variations of null checks
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-import App from '../../../base'
-import PDFJS from './pdfJsLoader'
-
-export default App.factory('pdfHighlights', function () {
-  let pdfHighlights
-  return (pdfHighlights = class pdfHighlights {
-    constructor(options) {
-      this.highlightsLayerDiv = options.highlights[0]
-      this.highlightElements = []
-    }
-
-    addHighlight(viewport, left, top, width, height) {
-      let rect = viewport.convertToViewportRectangle([
-        left,
-        top,
-        left + width,
-        top + height,
-      ])
-      rect = PDFJS.Util.normalizeRect(rect)
-      const element = document.createElement('div')
-      element.style.left = Math.floor(rect[0]) + 'px'
-      element.style.top = Math.floor(rect[1]) + 'px'
-      element.style.width = Math.ceil(rect[2] - rect[0]) + 'px'
-      element.style.height = Math.ceil(rect[3] - rect[1]) + 'px'
-      this.highlightElements.push(element)
-      this.highlightsLayerDiv.appendChild(element)
-      return element
-    }
-
-    clearHighlights() {
-      for (const h of Array.from(this.highlightElements)) {
-        if (h != null) {
-          h.parentNode.removeChild(h)
-        }
-      }
-      return (this.highlightElements = [])
-    }
-  })
-})

services/web/frontend/js/ide/pdfng/directives/pdfJs.js

@@ -1,212 +0,0 @@
-/* eslint-disable
-    max-len,
-    no-cond-assign,
-    no-return-assign,
-*/
-// TODO: This file was created by bulk-decaffeinate.
-// Fix any style issues and re-enable lint.
-/*
- * decaffeinate suggestions:
- * DS101: Remove unnecessary use of Array.from
- * DS102: Remove unnecessary code created because of implicit returns
- * DS207: Consider shorter variations of null checks
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-import App from '../../../base'
-import './pdfViewer'
-
-export default App.directive('pdfng', ($timeout, localStorage) => ({
-  scope: {
-    pdfSrc: '=',
-    highlights: '=',
-    position: '=',
-    dblClickCallback: '=',
-    firstRenderDone: '=',
-    updateConsumedBandwidth: '=',
-  },
-  link(scope, element, attrs) {
-    scope.loading = false
-    scope.pleaseJumpTo = null
-    scope.scale = null
-    let initializedPosition = false
-    const initializePosition = function () {
-      let position, scale
-      if (initializedPosition) {
-        return
-      }
-      initializedPosition = true
-
-      if ((scale = localStorage('pdf.scale')) != null) {
-        scope.scale = { scaleMode: scale.scaleMode, scale: +scale.scale }
-      } else {
-        scope.scale = { scaleMode: 'scale_mode_fit_width' }
-      }
-
-      if ((position = localStorage(`pdf.position.${attrs.key}`))) {
-        scope.position = {
-          page: +position.page,
-          offset: {
-            top: +position.offset.top,
-            left: +position.offset.left,
-          },
-        }
-      }
-
-      scope.$on('$destroy', () => {
-        localStorage('pdf.scale', scope.scale)
-        return localStorage(`pdf.position.${attrs.key}`, scope.position)
-      })
-
-      return $(window).unload(() => {
-        localStorage('pdf.scale', scope.scale)
-        return localStorage(`pdf.position.${attrs.key}`, scope.position)
-      })
-    }
-
-    const flashControls = () =>
-      scope.$evalAsync(function () {
-        scope.flashControls = true
-        return $timeout(() => (scope.flashControls = false), 1000)
-      })
-
-    scope.$on('pdfDoubleClick', (event, e) =>
-      typeof scope.dblClickCallback === 'function'
-        ? scope.dblClickCallback({
-            page: e.page - 1,
-            offset: { top: e.y, left: e.x },
-          })
-        : undefined
-    )
-
-    scope.$on('flash-controls', () => flashControls())
-
-    scope.$watch('pdfSrc', function (url) {
-      if (url) {
-        scope.loading = true
-        scope.loaded = false
-        scope.progress = 1
-        initializePosition()
-        return flashControls()
-      }
-    })
-
-    scope.$on('loaded', function () {
-      scope.loaded = true
-      scope.progress = 100
-      return $timeout(function () {
-        scope.loading = false
-        return delete scope.progress
-      }, 500)
-    })
-
-    scope.fitToHeight = function () {
-      const scale = angular.copy(scope.scale)
-      scale.scaleMode = 'scale_mode_fit_height'
-      return (scope.scale = scale)
-    }
-
-    scope.fitToWidth = function () {
-      const scale = angular.copy(scope.scale)
-      scale.scaleMode = 'scale_mode_fit_width'
-      return (scope.scale = scale)
-    }
-
-    scope.zoomIn = function () {
-      const scale = angular.copy(scope.scale)
-      scale.scaleMode = 'scale_mode_value'
-      scale.scale = scale.scale * 1.2
-      return (scope.scale = scale)
-    }
-
-    scope.zoomOut = function () {
-      const scale = angular.copy(scope.scale)
-      scale.scaleMode = 'scale_mode_value'
-      scale.scale = scale.scale / 1.2
-      return (scope.scale = scale)
-    }
-
-    if (attrs.resizeOn != null) {
-      for (const event of Array.from(attrs.resizeOn.split(','))) {
-        scope.$on(event, function (e) {})
-      }
-    }
-    // console.log 'got a resize event', event, e
-
-    scope.$on('progress', (event, progress) =>
-      scope.$apply(function () {
-        if (scope.loaded) {
-          return
-        }
-        scope.progress = Math.floor((progress.loaded / progress.total) * 100)
-        if (scope.progress > 100) {
-          scope.progress = 100
-        }
-        if (scope.progress < 0) {
-          return (scope.progress = 0)
-        }
-      })
-    )
-
-    return scope.$on('$destroy', function () {})
-  },
-  // console.log 'pdfjs destroy event'
-
-  template: `\
-<div
-    data-pdf-viewer
-    class="pdfjs-viewer"
-    tabindex="0"
-    pdf-src='pdfSrc'
-    position='position'
-    scale='scale'
-    highlights='highlights'
-    please-jump-to='pleaseJumpTo'
-    first-render-done="firstRenderDone"
-    update-consumed-bandwidth="updateConsumedBandwidth"
->
-</div>
-<div class="pdfjs-controls" ng-class="{'flash': flashControls }">
-  <div class="btn-group">
-      <a href
-          class="btn btn-info btn-lg"
-          ng-click="fitToWidth()"
-          tooltip="Fit to Width"
-          tooltip-append-to-body="true"
-          tooltip-placement="bottom"
-      >
-          <i class="fa fa-fw fa-arrows-h"></i>
-      </a>
-      <a href
-          class="btn btn-info btn-lg"
-          ng-click="fitToHeight()"
-          tooltip="Fit to Height"
-          tooltip-append-to-body="true"
-          tooltip-placement="bottom"
-      >
-          <i class="fa fa-fw fa-arrows-v"></i>
-      </a>
-      <a href
-          class="btn btn-info btn-lg"
-          ng-click="zoomIn()"
-          tooltip="Zoom In"
-          tooltip-append-to-body="true"
-          tooltip-placement="bottom"
-      >
-          <i class="fa fa-fw fa-search-plus"></i>
-      </a>
-      <a href
-          class="btn btn-info btn-lg"
-          ng-click="zoomOut()"
-          tooltip="Zoom Out"
-          tooltip-append-to-body="true"
-          tooltip-placement="bottom"
-      >
-          <i class="fa fa-fw fa-search-minus"></i>
-      </a>
-  </div>
-</div>
-<div class="progress-thin" ng-show="loading">
-  <div class="progress-bar" ng-style="{ 'width': progress + '%' }"></div>
-</div>\
-`,
-}))

services/web/frontend/js/ide/pdfng/directives/pdfJsLoader.js

@@ -1,28 +0,0 @@
-/*
- * Adapted from https://github.com/mozilla/pdfjs-dist/blob/e9492b7a725ec4edd466880223474f4295a5fb45/webpack.js
- * The PDF.js worker needs to be loaded in a Web Worker. This can be done
- * automatically with webpack via worker-loader.
- * PDF.js has the above file to do this, however it uses the webpack loader
- * module loading syntax, which prevents us from customising the loader.
- * We need to output the worker file to the public/js directory, and so we need
- * to customise the loader's options. However the rest of the file is identical
- * to the one provided by PDF.js.
- */
-/*
- * Adapted from https://github.com/mozilla/pdfjs-dist/blob/e9492b7a725ec4edd466880223474f4295a5fb45/webpack.js
- * The PDF.js worker needs to be loaded in a Web Worker. This can be done
- * automatically with webpack via worker-loader.
- * PDF.js has the above file to do this, however it uses the webpack loader
- * module loading syntax, which prevents us from customising the loader.
- * We need to output the worker file to the public/js directory, and so we need
- * to customise the loader's options. However the rest of the file is identical
- * to the one provided by PDF.js.
- */
-const pdfjs = require('../../../vendor/libs/pdfjs-dist/build/pdf.js')
-const PdfjsWorker = require('../../../vendor/libs/pdfjs-dist/build/pdf.worker.js')
-
-if (typeof window !== 'undefined' && 'Worker' in window) {
-  pdfjs.GlobalWorkerOptions.workerPort = new PdfjsWorker()
-}
-
-module.exports = pdfjs

services/web/frontend/js/ide/pdfng/directives/pdfPage.js

@@ -1,166 +0,0 @@
-/* eslint-disable
-    max-len,
-    new-cap,
-    no-return-assign,
-*/
-// TODO: This file was created by bulk-decaffeinate.
-// Fix any style issues and re-enable lint.
-/*
- * decaffeinate suggestions:
- * DS101: Remove unnecessary use of Array.from
- * DS102: Remove unnecessary code created because of implicit returns
- * DS205: Consider reworking code to avoid use of IIFEs
- * DS207: Consider shorter variations of null checks
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-import App from '../../../base'
-
-export default App.directive(
-  'pdfPage',
-  ($timeout, pdfHighlights, pdfSpinner) => ({
-    require: '^pdfViewer',
-    template: `\
-<div class="plv-page-view page-view">
-  <div class="pdf-canvas pdfng-empty"></div>
-  <div class="plv-text-layer text-layer"></div>
-  <div class="plv-annotations-layer annotations-layer"></div>
-  <div class="plv-highlights-layer highlights-layer"></div>
-</div>\
-`,
-    link(scope, element, attrs, ctrl) {
-      const canvasElement = $(element).find('.pdf-canvas')
-      const textElement = $(element).find('.text-layer')
-      const annotationsElement = $(element).find('.annotations-layer')
-      const highlightsElement = $(element).find('.highlights-layer')
-
-      const updatePageSize = function (size) {
-        const h = Math.floor(size[0])
-        const w = Math.floor(size[1])
-        element.height(h)
-        element.width(w)
-        canvasElement.height(h)
-        canvasElement.width(w)
-        return (scope.page.sized = true)
-      }
-
-      // keep track of our page element, so we can access it in the
-      // parent with scope.pages[i].element, and the contained
-      // elements for each part
-      scope.page.element = element
-      scope.page.elementChildren = {
-        canvas: canvasElement,
-        text: textElement,
-        annotations: annotationsElement,
-        highlights: highlightsElement,
-        container: element,
-      }
-
-      if (!scope.page.sized) {
-        if (scope.defaultPageSize != null) {
-          updatePageSize(scope.defaultPageSize)
-        } else {
-          // shouldn't get here - the default page size should now
-          // always be set before redraw is called
-          const handler = scope.$watch(
-            'defaultPageSize',
-            function (defaultPageSize) {
-              if (defaultPageSize == null) {
-                return
-              }
-              updatePageSize(defaultPageSize)
-              return handler()
-            }
-          )
-        }
-      }
-
-      if (scope.page.current) {
-        // console.log 'we must scroll to this page', scope.page.pageNum, 'at position', scope.page.position
-        // this is the current page, we want to scroll it into view
-        // and render it immediately
-        scope.document.renderPage(scope.page)
-        ctrl.setPdfPosition(scope.page, scope.page.position)
-      }
-
-      element.on('dblclick', function (e) {
-        const offset = $(element).find('.pdf-canvas').offset()
-        const dx = e.pageX - offset.left
-        const dy = e.pageY - offset.top
-        return scope.document
-          .getPdfViewport(scope.page.pageNum)
-          .then(function (viewport) {
-            const pdfPoint = viewport.convertToPdfPoint(dx, dy)
-            const event = {
-              page: scope.page.pageNum,
-              x: pdfPoint[0],
-              y: viewport.viewBox[3] - pdfPoint[1],
-            }
-            return scope.$emit('pdfDoubleClick', event)
-          })
-      })
-
-      const highlightsLayer = new pdfHighlights({
-        highlights: highlightsElement,
-      })
-
-      scope.$on('pdf:highlights', function (event, highlights) {
-        let h
-        if (highlights == null) {
-          return
-        }
-        if (!(highlights.length > 0)) {
-          return
-        }
-        if (scope.timeoutHandler) {
-          $timeout.cancel(scope.timeoutHandler)
-          highlightsLayer.clearHighlights()
-          scope.timeoutHandler = null
-        }
-
-        // console.log 'got highlight watch in pdfPage', scope.page
-        const pageHighlights = (() => {
-          const result = []
-          for (h of Array.from(highlights)) {
-            if (h.page === scope.page.pageNum) {
-              result.push(h)
-            }
-          }
-          return result
-        })()
-        if (!pageHighlights.length) {
-          return
-        }
-        scope.document.getPdfViewport(scope.page.pageNum).then(viewport =>
-          (() => {
-            const result1 = []
-            for (const hl of Array.from(pageHighlights)) {
-              // console.log 'adding highlight', h, viewport
-              const top = viewport.viewBox[3] - hl.v
-              result1.push(
-                highlightsLayer.addHighlight(
-                  viewport,
-                  hl.h,
-                  top,
-                  hl.width,
-                  hl.height
-                )
-              )
-            }
-            return result1
-          })()
-        )
-        return (scope.timeoutHandler = $timeout(function () {
-          highlightsLayer.clearHighlights()
-          return (scope.timeoutHandler = null)
-        }, 1000))
-      })
-
-      return scope.$on('$destroy', function () {
-        if (scope.timeoutHandler != null) {
-          $timeout.cancel(scope.timeoutHandler)
-          return highlightsLayer.clearHighlights()
-        }
-      })
-    },
-  })
-)

services/web/frontend/js/ide/pdfng/directives/pdfRenderer.js

@@ -1,558 +0,0 @@
-/* eslint-disable
-    node/handle-callback-err,
-    max-len,
-    new-cap,
-    no-return-assign,
-    no-unused-vars,
-*/
-// TODO: This file was created by bulk-decaffeinate.
-// Fix any style issues and re-enable lint.
-/*
- * decaffeinate suggestions:
- * DS101: Remove unnecessary use of Array.from
- * DS102: Remove unnecessary code created because of implicit returns
- * DS103: Rewrite code to no longer use __guard__
- * DS205: Consider reworking code to avoid use of IIFEs
- * DS206: Consider reworking classes to avoid initClass
- * DS207: Consider shorter variations of null checks
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-import App from '../../../base'
-import PDFJS from './pdfJsLoader'
-import { captureMessage } from '../../../infrastructure/error-reporter'
-
-export default App.factory(
-  'PDFRenderer',
-  function ($timeout, pdfAnnotations, pdfTextLayer, pdfSpinner) {
-    let PDFRenderer
-    return (PDFRenderer = (function () {
-      PDFRenderer = class PDFRenderer {
-        static initClass() {
-          this.prototype.JOB_QUEUE_INTERVAL = 25
-          this.prototype.PAGE_LOAD_TIMEOUT = 60 * 1000
-          this.prototype.INDICATOR_DELAY1 = 100 // time to delay before showing the indicator
-          this.prototype.INDICATOR_DELAY2 = 250 // time until the indicator starts animating
-          this.prototype.TEXTLAYER_TIMEOUT = 100
-        }
-
-        constructor(url, options) {
-          // set up external character mappings - needed for Japanese etc
-          this.url = url
-          this.options = options
-
-          this.scale = this.options.scale || 1
-
-          let disableFontFace
-          if (
-            __guard__(
-              window.location != null ? window.location.search : undefined,
-              x => x.indexOf('disable-font-face=true')
-            ) >= 0
-          ) {
-            disableFontFace = true
-          } else {
-            disableFontFace = false
-          }
-          this.pdfjs = PDFJS.getDocument({
-            url: this.url,
-            cMapUrl: window.pdfCMapsPath,
-            cMapPacked: true,
-            disableFontFace,
-            // Enable fetching with Range headers to restrict individual
-            // requests to 128kb.
-            // To do this correctly we must:
-            // a) disable auto-fetching of the whole file upfront
-            // b) disable streaming (which in this context means streaming of
-            // the response into memory). This isn't supported when using
-            // Range headers, but shouldn't be a problem since we are already
-            // limiting individual response size through chunked range
-            // requests
-            rangeChunkSize: 128 * 1024,
-            disableAutoFetch: !!this.options.disableAutoFetch,
-            disableStream: !!this.options.disableAutoFetch,
-          })
-          this.errorCallback = this.options.errorCallback
-          this.pageSizeChangeCallback = this.options.pageSizeChangeCallback
-          this.pdfjs.onProgress = this.options.progressCallback
-          this.document = this.pdfjs
-          this.navigateFn = this.options.navigateFn
-          this.spinner = new pdfSpinner()
-          this.resetState()
-          this.document.promise
-            .then(pdfDocument => {
-              return pdfDocument.getDownloadInfo().then(() => {
-                return this.options.loadedCallback()
-              })
-            })
-            .catch(exception => {
-              // error getting document
-              return this.errorCallback(exception)
-            })
-        }
-
-        resetState() {
-          this.renderQueue = []
-          if (this.queueTimer != null) {
-            clearTimeout(this.queueTimer)
-          }
-          // clear any existing timers, render tasks
-          for (const timer of Array.from(this.spinTimer || [])) {
-            clearTimeout(timer)
-          }
-          for (const page of Array.from(this.pageState || [])) {
-            __guard__(page != null ? page.loadTask : undefined, x => x.cancel())
-            __guard__(page != null ? page.renderTask : undefined, x1 =>
-              x1.cancel()
-            )
-          }
-          // initialise/reset the state
-          this.pageState = []
-          this.spinTimer = [] // timers for starting the spinners (to avoid jitter)
-          this.spinTimerDone = [] // array of pages where the spinner has activated
-          return (this.jobs = 0)
-        }
-
-        getNumPages() {
-          return this.document.promise.then(pdfDocument => pdfDocument.numPages)
-        }
-
-        getPage(pageNum) {
-          return this.document.promise.then(pdfDocument =>
-            pdfDocument.getPage(pageNum)
-          )
-        }
-
-        getPdfViewport(pageNum, scale) {
-          if (scale == null) {
-            ;({ scale } = this)
-          }
-          return this.document.promise.then(pdfDocument => {
-            return pdfDocument.getPage(pageNum).then(
-              function (page) {
-                let viewport
-                return (viewport = page.getViewport({ scale: scale }))
-              },
-              error => {
-                return typeof this.errorCallback === 'function'
-                  ? this.errorCallback(error)
-                  : undefined
-              }
-            )
-          })
-        }
-
-        getDestinations() {
-          return this.document.promise.then(pdfDocument =>
-            pdfDocument.getDestinations()
-          )
-        }
-
-        getDestination(dest) {
-          return this.document.promise.then(
-            pdfDocument => pdfDocument.getDestination(dest),
-            error => {
-              return typeof this.errorCallback === 'function'
-                ? this.errorCallback(error)
-                : undefined
-            }
-          )
-        }
-
-        getPageIndex(ref) {
-          return this.document.promise.then(pdfDocument => {
-            return pdfDocument.getPageIndex(ref).then(
-              idx => idx,
-              error => {
-                return typeof this.errorCallback === 'function'
-                  ? this.errorCallback(error)
-                  : undefined
-              }
-            )
-          })
-        }
-
-        getScale() {
-          return this.scale
-        }
-
-        setScale(scale) {
-          this.scale = scale
-          return this.resetState()
-        }
-
-        triggerRenderQueue(interval) {
-          if (interval == null) {
-            interval = this.JOB_QUEUE_INTERVAL
-          }
-          if (this.queueTimer != null) {
-            clearTimeout(this.queueTimer)
-          }
-          return (this.queueTimer = setTimeout(() => {
-            this.queueTimer = null
-            return this.processRenderQueue()
-          }, interval))
-        }
-
-        removeCompletedJob(pagenum) {
-          this.jobs = this.jobs - 1
-          return this.triggerRenderQueue(0)
-        }
-
-        renderPages(pages) {
-          if (this.shuttingDown) {
-            return
-          }
-          this.renderQueue = Array.from(pages).map(page => ({
-            element: page.elementChildren,
-            pagenum: page.pageNum,
-          }))
-          return this.triggerRenderQueue()
-        }
-
-        renderPage(page) {
-          if (this.shuttingDown) {
-            return
-          }
-          const current = {
-            element: page.elementChildren,
-            pagenum: page.pageNum,
-          }
-          this.renderQueue.push(current)
-          return this.processRenderQueue()
-        }
-
-        getPageDetails(page) {
-          return [page.element.canvas, page.pagenum]
-        }
-
-        // handle the loading indicators for each page
-
-        startIndicators() {
-          // make an array of the pages in the queue
-          this.queuedPages = []
-          for (const page of Array.from(this.renderQueue)) {
-            this.queuedPages[page.pagenum] = true
-          }
-          // clear any unfinished spinner timers on pages that aren't in the queue any more
-          for (const pagenum in this.spinTimer) {
-            if (!this.queuedPages[pagenum]) {
-              clearTimeout(this.spinTimer[pagenum])
-              delete this.spinTimer[pagenum]
-            }
-          }
-          // add indicators for any new pages in the current queue
-          return (() => {
-            const result = []
-            for (const page of Array.from(this.renderQueue)) {
-              if (
-                !this.spinTimer[page.pagenum] &&
-                !this.spinTimerDone[page.pagenum]
-              ) {
-                result.push(this.startIndicator(page))
-              }
-            }
-            return result
-          })()
-        }
-
-        startIndicator(page) {
-          const [canvas, pagenum] = Array.from(this.getPageDetails(page))
-          canvas.addClass('pdfng-loading')
-          return (this.spinTimer[pagenum] = setTimeout(() => {
-            for (const queuedPage of Array.from(this.renderQueue)) {
-              if (pagenum === queuedPage.pagenum) {
-                this.spinner.add(canvas, { static: true })
-                this.spinTimerDone[pagenum] = true
-                break
-              }
-            }
-            return delete this.spinTimer[pagenum]
-          }, this.INDICATOR_DELAY1))
-        }
-
-        updateIndicator(page) {
-          const [canvas, pagenum] = Array.from(this.getPageDetails(page))
-          // did the spinner insert itself already?
-          if (this.spinTimerDone[pagenum]) {
-            return (this.spinTimer[pagenum] = setTimeout(() => {
-              this.spinner.start(canvas)
-              return delete this.spinTimer[pagenum]
-            }, this.INDICATOR_DELAY2))
-          } else {
-            // stop the existing spin timer
-            clearTimeout(this.spinTimer[pagenum])
-            // start a new one which will also start spinning
-            return (this.spinTimer[pagenum] = setTimeout(() => {
-              this.spinner.add(canvas, { static: true })
-              this.spinTimerDone[pagenum] = true
-              return (this.spinTimer[pagenum] = setTimeout(() => {
-                this.spinner.start(canvas)
-                return delete this.spinTimer[pagenum]
-              }, this.INDICATOR_DELAY2))
-            }, this.INDICATOR_DELAY1))
-          }
-        }
-
-        clearIndicator(page) {
-          const [canvas, pagenum] = Array.from(this.getPageDetails(page))
-          this.spinner.stop(canvas)
-          clearTimeout(this.spinTimer[pagenum])
-          delete this.spinTimer[pagenum]
-          return (this.spinTimerDone[pagenum] = true)
-        }
-
-        // handle the queue of pages to be rendered
-
-        processRenderQueue() {
-          let pageState
-          if (this.shuttingDown) {
-            return
-          }
-          // mark all pages in the queue as loading
-          this.startIndicators()
-          // bail out if there is already a render job running
-          if (this.jobs > 0) {
-            return
-          }
-          // take the first page in the queue
-          let page = this.renderQueue.shift()
-          // check if it is in action already
-          while (page != null && this.pageState[page.pagenum] != null) {
-            page = this.renderQueue.shift()
-          }
-          if (page == null) {
-            return
-          }
-          const [element, pagenum] = Array.from([page.element, page.pagenum])
-          this.jobs = this.jobs + 1
-
-          // update the spinner to make it spinning (signifies loading has begun)
-          this.updateIndicator(page)
-
-          let timedOut = false
-          const timer = $timeout(() => {
-            // page load timed out
-            if (loadTask.cancelled) {
-              return
-            } // return from cancelled page load
-            captureMessage(
-              `pdfng page load timed out after ${this.PAGE_LOAD_TIMEOUT}ms`
-            )
-
-            timedOut = true
-            this.clearIndicator(page)
-            // @jobs = @jobs - 1
-            // @triggerRenderQueue(0)
-            return typeof this.errorCallback === 'function'
-              ? this.errorCallback('timeout')
-              : undefined
-          }, this.PAGE_LOAD_TIMEOUT)
-
-          const loadTask = this.getPage(pagenum)
-
-          loadTask.cancel = function () {
-            return (this.cancelled = true)
-          }
-
-          this.pageState[pagenum] = pageState = { loadTask }
-
-          return loadTask
-            .then(pageObject => {
-              // page load success
-              $timeout.cancel(timer)
-              if (loadTask.cancelled) {
-                return
-              } // return from cancelled page load
-              const timePDFFetched = performance.now()
-
-              const visible = !document.hidden
-              if (!visible) {
-                // Flush the fetch time early, omit the render time.
-                if (typeof this.options.firstRenderDone === 'function') {
-                  this.options.firstRenderDone({ timePDFFetched })
-                  // Do not submit the actual rendering time.
-                  this.options.firstRenderDone = null
-                }
-              }
-
-              pageState.renderTask = this.doRender(element, pagenum, pageObject)
-              return pageState.renderTask.promise.then(
-                () => {
-                  if (typeof this.options.firstRenderDone === 'function') {
-                    const timePDFRendered = performance.now()
-                    this.options.firstRenderDone({
-                      timePDFFetched,
-                      timePDFRendered,
-                    })
-                    // The rendering pipeline is processed repeatedly, skip the next ones.
-                    this.options.firstRenderDone = null
-                  }
-
-                  // render task success
-                  this.clearIndicator(page)
-                  pageState.complete = true
-                  delete pageState.renderTask
-                  return this.removeCompletedJob(pagenum)
-                },
-                () => {
-                  // render task failed
-                  // could display an error icon
-                  pageState.complete = false
-                  delete pageState.renderTask
-                  return this.removeCompletedJob(pagenum)
-                }
-              )
-            })
-            .catch(error => {
-              // page load error
-              $timeout.cancel(timer)
-              return this.clearIndicator(page)
-            })
-        }
-
-        doRender(element, pagenum, page) {
-          const self = this
-          const { scale } = this
-
-          if (scale == null) {
-            // scale is undefined, returning
-            return
-          }
-
-          const canvas = $(
-            '<canvas class="pdf-canvas pdfng-rendering"></canvas>'
-          )
-          // In Windows+IE we must have the canvas in the DOM during
-          // rendering to see the fonts defined in the DOM. If we try to
-          // render 'offscreen' then all the text will be sans-serif.
-          // Previously we rendered offscreen and added in the canvas
-          // when rendering was complete.
-          element.canvas.replaceWith(canvas)
-
-          const viewport = page.getViewport({ scale: scale })
-
-          const devicePixelRatio = window.devicePixelRatio || 1
-
-          const ctx = canvas[0].getContext('2d')
-          const backingStoreRatio =
-            ctx.webkitBackingStorePixelRatio ||
-            ctx.mozBackingStorePixelRatio ||
-            ctx.msBackingStorePixelRatio ||
-            ctx.oBackingStorePixelRatio ||
-            ctx.backingStorePixelRatio ||
-            1
-          const pixelRatio = devicePixelRatio / backingStoreRatio
-
-          const scaledWidth = (Math.floor(viewport.width) * pixelRatio) | 0
-          const scaledHeight = (Math.floor(viewport.height) * pixelRatio) | 0
-
-          const newWidth = Math.floor(viewport.width)
-          const newHeight = Math.floor(viewport.height)
-
-          canvas[0].height = scaledHeight
-          canvas[0].width = scaledWidth
-
-          canvas.height(newHeight + 'px')
-          canvas.width(newWidth + 'px')
-
-          const oldHeight = element.canvas.height()
-          const oldWidth = element.canvas.width()
-          if (newHeight !== oldHeight || newWidth !== oldWidth) {
-            element.canvas.height(newHeight + 'px')
-            element.canvas.width(newWidth + 'px')
-            element.container.height(newHeight + 'px')
-            element.container.width(newWidth + 'px')
-            if (typeof this.pageSizeChangeCallback === 'function') {
-              this.pageSizeChangeCallback(pagenum, newHeight - oldHeight)
-            }
-          }
-
-          const textLayer = new pdfTextLayer({
-            textLayerDiv: element.text[0],
-            viewport,
-            renderer: PDFJS.renderTextLayer,
-          })
-
-          const annotationsLayer = new pdfAnnotations({
-            annotations: element.annotations[0],
-            viewport,
-            navigateFn: this.navigateFn,
-          })
-
-          const result = page.render({
-            canvasContext: ctx,
-            viewport,
-            transform: [pixelRatio, 0, 0, pixelRatio, 0, 0],
-          })
-
-          const textLayerTimeout = this.TEXTLAYER_TIMEOUT
-
-          result.promise
-            .then(function () {
-              // page render success
-              canvas.removeClass('pdfng-rendering')
-              page.getTextContent({ normalizeWhitespace: true }).then(
-                function (textContent) {
-                  textLayer.setTextContent(textContent)
-                  return textLayer.render(textLayerTimeout)
-                },
-                error =>
-                  typeof self.errorCallback === 'function'
-                    ? self.errorCallback(error)
-                    : undefined
-              )
-              return page.getAnnotations().then(
-                annotations => annotationsLayer.setAnnotations(annotations),
-                error =>
-                  typeof self.errorCallback === 'function'
-                    ? self.errorCallback(error)
-                    : undefined
-              )
-            })
-            .catch(function (error) {
-              // page render failed
-              if (error.name === 'RenderingCancelledException') {
-                // do nothing when cancelled
-              } else {
-                return typeof self.errorCallback === 'function'
-                  ? self.errorCallback(error)
-                  : undefined
-              }
-            })
-
-          return result
-        }
-
-        destroy() {
-          this.shuttingDown = true
-          this.resetState()
-          return this.pdfjs.promise
-            .then(function (document) {
-              document.cleanup()
-              return document.destroy()
-            })
-            .catch(() => {})
-        }
-      }
-      PDFRenderer.initClass()
-      return PDFRenderer
-    })())
-  }
-)
-
-function __guard__(value, transform) {
-  return typeof value !== 'undefined' && value !== null
-    ? transform(value)
-    : undefined
-}
-function __guardMethod__(obj, methodName, transform) {
-  if (
-    typeof obj !== 'undefined' &&
-    obj !== null &&
-    typeof obj[methodName] === 'function'
-  ) {
-    return transform(obj, methodName)
-  } else {
-    return undefined
-  }
-}

services/web/frontend/js/ide/pdfng/directives/pdfSpinner.js

@@ -1,45 +0,0 @@
-/* eslint-disable
-    max-len,
-    no-unused-vars,
-    no-useless-constructor,
-*/
-// TODO: This file was created by bulk-decaffeinate.
-// Fix any style issues and re-enable lint.
-/*
- * decaffeinate suggestions:
- * DS102: Remove unnecessary code created because of implicit returns
- * DS207: Consider shorter variations of null checks
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-import App from '../../../base'
-
-export default App.factory('pdfSpinner', function () {
-  let pdfSpinner
-  return (pdfSpinner = class pdfSpinner {
-    constructor() {}
-    // handler for spinners
-
-    add(element, options) {
-      const size = 64
-      const spinner = $(
-        `<div class="pdfng-spinner" style="position: absolute; top: 50%; left:50%; transform: translateX(-50%) translateY(-50%);"><i class="fa fa-spinner${
-          (options != null ? options.static : undefined) ? '' : ' fa-spin'
-        }" style="color: #999"></i></div>`
-      )
-      spinner.css({ 'font-size': size + 'px' })
-      return element.append(spinner)
-    }
-
-    start(element) {
-      return element.find('.fa-spinner').addClass('fa-spin')
-    }
-
-    stop(element) {
-      return element.find('.fa-spinner').removeClass('fa-spin')
-    }
-
-    remove(element) {
-      return element.find('.fa-spinner').remove()
-    }
-  })
-})

services/web/frontend/js/ide/pdfng/directives/pdfTextLayer.js

@@ -1,77 +0,0 @@
-/* eslint-disable
-    max-len,
-    no-return-assign,
-    no-unused-vars,
-*/
-// TODO: This file was created by bulk-decaffeinate.
-// Fix any style issues and re-enable lint.
-/*
- * decaffeinate suggestions:
- * DS102: Remove unnecessary code created because of implicit returns
- * DS207: Consider shorter variations of null checks
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-import App from '../../../base'
-// uses the PDFJS text layer renderer to provide invisible overlayed
-// text for searching
-
-App.factory('pdfTextLayer', function () {
-  let pdfTextLayer
-  return (pdfTextLayer = class pdfTextLayer {
-    constructor(options) {
-      this.textLayerDiv = options.textLayerDiv
-      this.divContentDone = false
-      this.viewport = options.viewport
-      this.textDivs = []
-      this.renderer = options.renderer
-      this.renderingDone = false
-    }
-
-    render(timeout) {
-      if (this.renderingDone || !this.divContentDone) {
-        return
-      }
-
-      if (this.textLayerRenderTask != null) {
-        this.textLayerRenderTask.cancel()
-        this.textLayerRenderTask = null
-      }
-
-      this.textDivs = []
-      const textLayerFrag = document.createDocumentFragment()
-
-      this.textLayerRenderTask = this.renderer({
-        textContent: this.textContent,
-        container: textLayerFrag,
-        viewport: this.viewport,
-        textDivs: this.textDivs,
-        timeout,
-        enhanceTextSelection: this.enhanceTextSelection,
-      })
-
-      const textLayerSuccess = () => {
-        this.textLayerDiv.appendChild(textLayerFrag)
-        return (this.renderingDone = true)
-      }
-
-      const textLayerFailure = function () {
-        // canceled or failed to render text layer -- skipping errors
-      }
-
-      return this.textLayerRenderTask.promise.then(
-        textLayerSuccess,
-        textLayerFailure
-      )
-    }
-
-    setTextContent(textContent) {
-      if (this.textLayerRenderTask) {
-        this.textLayerRenderTask.cancel()
-        this.textLayerRenderTask = null
-      }
-
-      this.textContent = textContent
-      return (this.divContentDone = true)
-    }
-  })
-})

services/web/frontend/js/ide/pdfng/directives/pdfViewer.js

@@ -1,861 +0,0 @@
-import _ from 'lodash'
-/* eslint-disable
-    node/handle-callback-err,
-    max-len,
-    new-cap,
-    no-return-assign,
-    no-sequences,
-    no-unused-vars,
-*/
-// TODO: This file was created by bulk-decaffeinate.
-// Fix any style issues and re-enable lint.
-/*
- * decaffeinate suggestions:
- * DS101: Remove unnecessary use of Array.from
- * DS102: Remove unnecessary code created because of implicit returns
- * DS103: Rewrite code to no longer use __guard__
- * DS104: Avoid inline assignments
- * DS207: Consider shorter variations of null checks
- * Full docs: https://github.com/decaffeinate/decaffeinate/blob/master/docs/suggestions.md
- */
-import App from '../../../base'
-import { captureMessage } from '../../../infrastructure/error-reporter'
-import pdfTextLayer from './pdfTextLayer'
-import pdfAnnotations from './pdfAnnotations'
-import pdfHighlights from './pdfHighlights'
-import pdfRenderer from './pdfRenderer'
-import pdfPage from './pdfPage'
-import pdfSpinner from './pdfSpinner'
-App.controller(
-  'pdfViewerController',
-  function (
-    $scope,
-    $q,
-    $timeout,
-    PDFRenderer,
-    $element,
-    pdfHighlights,
-    pdfSpinner
-  ) {
-    this.load = function () {
-      // $scope.pages = []
-
-      // Ensure previous document is torn down before loading the next one (to
-      // prevent race conditions)
-      const documentTearDown =
-        $scope.document != null ? $scope.document.destroy() : Promise.resolve()
-      // Keep track of whether the pdf has loaded (this allows rescale events to
-      // be ignored until we are ready to render the pdf).
-      $scope.isLoaded = false
-      return documentTearDown.then(() => {
-        $scope.loadCount = $scope.loadCount != null ? $scope.loadCount + 1 : 1
-        // TODO need a proper url manipulation library to add to query string
-        let url = $scope.pdfSrc
-        // add 'pdfng=true' to show that we are using the angular pdfjs viewer
-        const queryStringExists = /\?/.test(url)
-        url = url + (!queryStringExists ? '?' : '&') + 'pdfng=true'
-
-        // Take references as these must be invoked for this very URL
-        const firstRenderDone = $scope.firstRenderDone
-        const updateConsumedBandwidth = $scope.updateConsumedBandwidth
-
-        // for isolated compiles, load the pdf on-demand because nobody will overwrite it
-        const onDemandLoading = true
-        $scope.document = new PDFRenderer(url, {
-          scale: 1,
-          disableAutoFetch: onDemandLoading ? true : undefined,
-          navigateFn(ref) {
-            // this function captures clicks on the annotation links
-            $scope.navigateTo = ref
-            return $scope.$apply()
-          },
-          progressCallback(progress) {
-            updateConsumedBandwidth(progress.loaded)
-            return $scope.$emit('progress', progress)
-          },
-          loadedCallback() {
-            return $scope.$emit('loaded')
-          },
-          firstRenderDone,
-          errorCallback(error) {
-            // MissingPDFException is "expected" as the pdf file can be on a
-            // CLSI server that has been cycled out.
-            // Currently, there is NO error handling to handle this situation,
-            // but we plan to add this in the future
-            // (https://github.com/overleaf/issues/issues/2985) and this error
-            // is causing noise in Sentry so ignore it
-            if (!error || error.name !== 'MissingPDFException') {
-              captureMessage(`pdfng error ${error}`)
-            }
-            return $scope.$emit('pdf:error', error)
-          },
-          pageSizeChangeCallback(pageNum, deltaH) {
-            return $scope.$broadcast('pdf:page:size-change', pageNum, deltaH)
-          },
-        })
-
-        // we will have all the main information needed to start display
-        // after the following promise is resolved
-        $scope.loaded = $q
-          .all({
-            numPages: $scope.document.getNumPages(),
-            // get size of first page as default @ scale 1
-            pdfViewport: $scope.document.getPdfViewport(1, 1),
-          })
-          .then(function (result) {
-            $scope.pdfViewport = result.pdfViewport
-            $scope.pdfPageSize = [
-              result.pdfViewport.height,
-              result.pdfViewport.width,
-            ]
-            // console.log 'resolved q.all, page size is', result
-            $scope.$emit('loaded')
-            // we can now render the document and handle rescale events
-            $scope.isLoaded = true
-            return ($scope.numPages = result.numPages)
-          })
-          .catch(function (error) {
-            $scope.$emit('pdf:error', error)
-            return $q.reject(error)
-          })
-
-        return $scope.loaded
-      })
-    }
-
-    this.setScale = (scale, containerHeight, containerWidth) =>
-      $scope.loaded
-        .then(function () {
-          let numScale
-          if (scale == null) {
-            scale = {}
-          }
-          if (containerHeight === 0 || containerWidth === 0) {
-            numScale = 1
-          } else if (scale.scaleMode === 'scale_mode_fit_width') {
-            // TODO make this dynamic
-            numScale = (containerWidth - 40) / $scope.pdfPageSize[1]
-          } else if (scale.scaleMode === 'scale_mode_fit_height') {
-            // TODO magic numbers for jquery ui layout
-            numScale = (containerHeight - 20) / $scope.pdfPageSize[0]
-          } else if (scale.scaleMode === 'scale_mode_value') {
-            numScale = scale.scale
-          } else if (scale.scaleMode === 'scale_mode_auto') {
-            // TODO
-          } else {
-            scale.scaleMode = 'scale_mode_fit_width'
-            numScale = (containerWidth - 40) / $scope.pdfPageSize[1]
-          }
-          // TODO
-          $scope.scale.scale = numScale
-          $scope.document.setScale(numScale)
-          return ($scope.defaultPageSize = [
-            numScale * $scope.pdfPageSize[0],
-            numScale * $scope.pdfPageSize[1],
-          ])
-        })
-        // console.log 'in setScale result', $scope.scale.scale, $scope.defaultPageSize
-        .catch(function (error) {
-          $scope.$emit('pdf:error', error)
-          return $q.reject(error)
-        })
-
-    this.redraw = function (position) {
-      // console.log 'in redraw'
-      // console.log 'reseting pages array for', $scope.numPages
-      $scope.pages = __range__(0, $scope.numPages - 1, true).map(i => ({
-        pageNum: i + 1,
-      }))
-      if (position != null && position.page != null) {
-        // console.log 'position is', position.page, position.offset
-        // console.log 'setting current page', position.page
-        let pagenum = position.page
-        if (pagenum > $scope.numPages - 1) {
-          pagenum = $scope.numPages - 1
-        }
-        $scope.pages[pagenum].current = true
-        return ($scope.pages[pagenum].position = position)
-      }
-    }
-
-    this.zoomIn = function () {
-      // console.log 'zoom in'
-      const newScale = $scope.scale.scale * 1.2
-      return ($scope.forceScale = {
-        scaleMode: 'scale_mode_value',
-        scale: newScale,
-      })
-    }
-
-    this.zoomOut = function () {
-      // console.log 'zoom out'
-      const newScale = $scope.scale.scale / 1.2
-      return ($scope.forceScale = {
-        scaleMode: 'scale_mode_value',
-        scale: newScale,
-      })
-    }
-
-    this.fitWidth = () =>
-      // console.log 'fit width'
-      ($scope.forceScale = { scaleMode: 'scale_mode_fit_width' })
-
-    this.fitHeight = () =>
-      // console.log 'fit height'
-      ($scope.forceScale = { scaleMode: 'scale_mode_fit_height' })
-
-    this.checkPosition = () =>
-      // console.log 'check position'
-      ($scope.forceCheck = ($scope.forceCheck || 0) + 1)
-
-    this.showRandomHighlights = () =>
-      // console.log 'show highlights'
-      ($scope.highlights = [
-        {
-          page: 3,
-          h: 100,
-          v: 100,
-          height: 30,
-          width: 200,
-        },
-      ])
-
-    // we work with (pagenumber, % of height down page from top)
-    // pdfListView works with (pagenumber, vertical position up page from
-    // bottom measured in pts)
-
-    this.getPdfPosition = function () {
-      // console.log 'in getPdfPosition'
-      let canvasOffset, pdfOffset, viewport
-      let topPageIdx = 0
-      let topPage = $scope.pages[0]
-      // find first visible page
-      const visible = $scope.pages.some(function (page, i) {
-        if (page.visible) {
-          let ref
-          return ([topPageIdx, topPage] = Array.from((ref = [i, page]))), ref
-        }
-        return false
-      })
-      if (visible && topPage.element != null) {
-        // console.log 'found it', topPageIdx
-      } else {
-        // console.log 'CANNOT FIND TOP PAGE'
-        return
-      }
-
-      // console.log 'top page is', topPage.pageNum, topPage.elemTop, topPage.elemBottom, topPage
-      const { top } = topPage.element.offset()
-      const bottom = top + topPage.element.innerHeight()
-      const viewportTop = $element.offset().top
-      const viewportBottom = viewportTop + $element.height()
-      const topVisible = top >= viewportTop && top < viewportBottom
-      const someContentVisible = top < viewportTop && bottom > viewportTop
-      // console.log 'in PdfListView', top, topVisible, someContentVisible, viewportTop
-      if (topVisible) {
-        canvasOffset = 0
-      } else if (someContentVisible) {
-        canvasOffset = viewportTop - top
-      } else {
-        canvasOffset = null
-      }
-      // console.log 'pdfListview position = ', canvasOffset
-      // instead of using promise, check if size is known and revert to
-      // default otherwise
-      // console.log 'looking up viewport', topPage.viewport, $scope.pdfViewport
-      if (topPage.viewport) {
-        ;({ viewport } = topPage)
-        pdfOffset = viewport.convertToPdfPoint(0, canvasOffset)
-      } else {
-        // console.log 'WARNING: had to default to global page size'
-        viewport = $scope.pdfViewport
-        const scaledOffset = canvasOffset / $scope.scale.scale
-        pdfOffset = viewport.convertToPdfPoint(0, scaledOffset)
-      }
-      // console.log 'converted to offset = ', pdfOffset
-      const newPosition = {
-        page: topPageIdx,
-        offset: { top: pdfOffset[1], left: 0 },
-        pageSize: { height: viewport.viewBox[3], width: viewport.viewBox[2] },
-      }
-      return newPosition
-    }
-
-    this.computeOffset = function (page, position) {
-      // console.log 'computing offset for', page, position
-      const { element } = page
-      // console.log 'element =', $(element), 'parent =', $(element).parent()
-      const t1 = __guard__($(element).offset(), x => x.top)
-      const t2 = __guard__($(element).parent().offset(), x1 => x1.top)
-      if (!(t1 != null && t2 != null)) {
-        return $q((resolve, reject) => reject('elements destroyed'))
-      }
-      const pageTop = $(element).offset().top - $(element).parent().offset().top
-      // console.log('top of page scroll is', pageTop, 'vs', page.elemTop)
-      // console.log('inner height is', $(element).innerHeight())
-      const currentScroll = $(element).parent().scrollTop()
-      const { offset } = position
-      // convert offset to pixels
-      return $scope.document
-        .getPdfViewport(page.pageNum)
-        .then(function (viewport) {
-          page.viewport = viewport
-          const pageOffset = viewport.convertToViewportPoint(
-            offset.left,
-            offset.top
-          )
-          // if the passed-in position doesn't have the page height/width add them now
-          if (position.pageSize == null) {
-            position.pageSize = {
-              height: viewport.viewBox[3],
-              width: viewport.viewBox[2],
-            }
-          }
-          // console.log 'addition offset =', pageOffset
-          // console.log 'total', pageTop + pageOffset[1]
-          return Math.round(pageTop + pageOffset[1] + currentScroll)
-        }) // # 10 is margin
-    }
-
-    this.setPdfPosition = function (page, position) {
-      // console.log 'required pdf Position is', position
-      return this.computeOffset(page, position).then(function (offset) {
-        return $scope.$apply(() => {
-          $scope.pleaseScrollTo = offset
-          $scope.position = position
-        })
-      })
-    }
-    return this
-  }
-)
-
-export default App.directive('pdfViewer', ($q, $timeout, pdfSpinner) => ({
-  controller: 'pdfViewerController',
-  controllerAs: 'ctrl',
-  scope: {
-    pdfSrc: '=',
-    firstRenderDone: '=',
-    updateConsumedBandwidth: '=',
-    highlights: '=',
-    position: '=',
-    scale: '=',
-    pleaseJumpTo: '=',
-  },
-  template: `\
-<div data-pdf-page class='pdf-page-container page-container' ng-repeat='page in pages'></div>\
-`,
-  link(scope, element, attrs, ctrl) {
-    // console.log 'in pdfViewer element is', element
-    // console.log 'attrs', attrs
-    const spinner = new pdfSpinner()
-    let layoutReady = $q.defer()
-    layoutReady.notify('waiting for layout')
-    layoutReady.promise.then(function () {})
-    // console.log 'layoutReady was resolved'
-
-    const renderVisiblePages = function () {
-      const visiblePages = getVisiblePages()
-      const pages = getExtraPages(visiblePages)
-      return scope.document.renderPages(pages)
-    }
-
-    function getVisiblePages() {
-      const top = element[0].scrollTop
-      const bottom = top + element[0].clientHeight
-      const visiblePages = _.filter(scope.pages, function (page) {
-        if (page.element == null) {
-          return false
-        }
-        const pageElement = page.element[0]
-        const pageTop = pageElement.offsetTop
-        const pageBottom = pageTop + pageElement.clientHeight
-        page.visible = pageTop < bottom && pageBottom > top
-        return page.visible
-      })
-      return visiblePages
-    }
-
-    function getExtraPages(visiblePages) {
-      const extra = []
-      if (visiblePages.length > 0) {
-        const firstVisiblePage = visiblePages[0].pageNum
-        const firstVisiblePageIdx = firstVisiblePage - 1
-        const len = visiblePages.length
-        const lastVisiblePage = visiblePages[len - 1].pageNum
-        const lastVisiblePageIdx = lastVisiblePage - 1
-        // first page after
-        if (lastVisiblePageIdx + 1 < scope.pages.length) {
-          extra.push(scope.pages[lastVisiblePageIdx + 1])
-        }
-        // page before
-        if (firstVisiblePageIdx > 0) {
-          extra.push(scope.pages[firstVisiblePageIdx - 1])
-        }
-        // second page after
-        if (lastVisiblePageIdx + 2 < scope.pages.length) {
-          extra.push(scope.pages[lastVisiblePageIdx + 2])
-        }
-      }
-      return visiblePages.concat(extra)
-    }
-
-    let rescaleTimer = null
-    const queueRescale = function (scale) {
-      // console.log 'call to queueRescale'
-      if (!scope.isLoaded) {
-        return // ignore any requests to rescale before the document is loaded
-      }
-      if (rescaleTimer != null || layoutTimer != null || elementTimer != null) {
-        return
-      }
-      // console.log 'adding to rescale queue'
-      return (rescaleTimer = setTimeout(function () {
-        doRescale(scale)
-        return (rescaleTimer = null)
-      }, 0))
-    }
-
-    let spinnerTimer = null
-    function doRescale(scale) {
-      // console.log 'doRescale', scale
-      if (scale == null) {
-        return
-      }
-      const origposition = angular.copy(scope.position)
-      // console.log 'origposition', origposition
-
-      if (spinnerTimer == null) {
-        spinnerTimer = setTimeout(function () {
-          spinner.add(element)
-          return (spinnerTimer = null)
-        }, 100)
-      }
-      return layoutReady.promise.then(function (parentSize) {
-        const [h, w] = Array.from(parentSize)
-        // console.log 'in promise', h, w
-        return ctrl
-          .setScale(scale, h, w)
-          .then(() =>
-            // console.log 'in setscale then', scale, h, w
-            scope.$evalAsync(function () {
-              if (spinnerTimer) {
-                clearTimeout(spinnerTimer)
-              } else {
-                spinner.remove(element)
-              }
-              // stop displaying the text layer
-              element.removeClass('pdfjs-viewer-show-text')
-              ctrl.redraw(origposition)
-              $timeout(renderVisiblePages)
-              return (scope.loadSuccess = true)
-            })
-          )
-          .catch(error => scope.$emit('pdf:error', error))
-      })
-    }
-
-    let elementTimer = null
-    function updateLayout() {
-      // if element is zero-sized keep checking until it is ready
-      // console.log 'checking element ready', element.height(), element.width()
-      if (element.height() === 0 || element.width() === 0) {
-        if (elementTimer != null) {
-          return
-        }
-        return (elementTimer = setTimeout(function () {
-          elementTimer = null
-          return updateLayout()
-        }, 1000))
-      } else {
-        scope.parentSize = [element.innerHeight(), element.innerWidth()]
-        // console.log 'resolving layoutReady with', scope.parentSize
-        return $timeout(function () {
-          layoutReady.resolve(scope.parentSize)
-          return scope.$emit('flash-controls')
-        })
-      }
-    }
-
-    let layoutTimer = null
-    const queueLayout = function () {
-      // console.log 'call to queue layout'
-      if (layoutTimer != null) {
-        return
-      }
-      // console.log 'added to queue layoyt'
-      layoutReady = $q.defer()
-      return (layoutTimer = setTimeout(function () {
-        // console.log 'calling update layout'
-        updateLayout()
-        // console.log 'setting layout timer to null'
-        return (layoutTimer = null)
-      }, 0))
-    }
-
-    queueLayout()
-
-    // scope.$on 'layout:pdf:view', (e, args) ->
-    //	console.log 'pdf view change', element, e, args
-    //	queueLayout()
-
-    scope.$on('layout:main:resize', () =>
-      // console.log 'GOT LAYOUT-MAIN-RESIZE EVENT'
-      queueLayout()
-    )
-
-    scope.$on('layout:pdf:resize', () =>
-      // FIXME we get this event twice
-      // also we need to start a new layout when we get it
-      // console.log 'GOT LAYOUT-PDF-RESIZE EVENT'
-      queueLayout()
-    )
-
-    scope.$on('pdf:error', function (event, error) {
-      if (error.name === 'RenderingCancelledException') {
-        return
-      }
-      // check if too many retries or file is missing
-      const message = (error != null ? error.message : undefined) || error
-      if (
-        scope.loadCount > 3 ||
-        /^Missing PDF/i.test(message) ||
-        /^loading/i.test(message)
-      ) {
-        scope.$emit('pdf:error:display')
-        return
-      }
-      if (scope.loadSuccess) {
-        return ctrl
-          .load()
-          .then(
-            () =>
-              // trigger a redraw
-              (scope.scale = angular.copy(scope.scale))
-          )
-          .catch(error => scope.$emit('pdf:error:display'))
-      } else {
-        scope.$emit('pdf:error:display')
-      }
-    })
-
-    scope.$on('pdf:page:size-change', function (event, pageNum, delta) {
-      // console.log 'page size change event', pageNum, delta
-      const origposition = angular.copy(scope.position)
-      // console.log 'orig position', JSON.stringify(origposition)
-      if (
-        origposition != null &&
-        pageNum - 1 < origposition.page &&
-        delta !== 0
-      ) {
-        const currentScrollTop = element.scrollTop()
-        // console.log 'adjusting scroll from', currentScrollTop, 'by', delta
-        scope.adjustingScroll = true
-        return element.scrollTop(currentScrollTop + delta)
-      }
-    })
-
-    element.on('mousedown', function (e) {
-      // We're checking that the event target isn't the directive root element
-      // to make sure that the click was within a PDF page - no point in showing
-      // the text layer when the click is outside.
-      // If the user clicks a PDF page, the mousedown target will be the canvas
-      // element (or the text layer one). Alternatively, if the event target is
-      // the root element, we can assume that the user has clicked either the
-      // grey background area or the scrollbars.
-      if (e.target !== element[0] && !_hasSelection()) {
-        element.addClass('pdfjs-viewer-show-text')
-        return _setMouseUpHandler()
-      }
-    })
-
-    let mouseUpHandler = null // keep track of the handler to avoid adding multiple times
-
-    function _setMouseUpHandler() {
-      if (mouseUpHandler == null) {
-        return (mouseUpHandler = $(document.body).one(
-          'mouseup',
-          _handleSelectionMouseUp
-        ))
-      }
-    }
-
-    function _handleSelectionMouseUp() {
-      mouseUpHandler = null // reset handler, has now fired
-      window.setTimeout(function () {
-        const removedClass = _removeClassIfNoSelection()
-        // if we still have a selection we need to keep the handler going
-        if (!removedClass) {
-          return _setMouseUpHandler()
-        }
-      }, 10)
-      return true
-    }
-
-    function _removeClassIfNoSelection() {
-      if (_hasSelection()) {
-        return false // didn't remove the text layer
-      } else {
-        element.removeClass('pdfjs-viewer-show-text')
-        return true
-      }
-    }
-
-    function _hasSelection() {
-      const selection =
-        typeof window.getSelection === 'function'
-          ? window.getSelection()
-          : undefined
-      // check the selection collapsed state in preference to
-      // using selection.toString() as the latter is "" when
-      // the selection is hidden (e.g. while viewing logs)
-      return (
-        selection != null &&
-        _isSelectionWithinPDF(selection) &&
-        !selection.isCollapsed
-      )
-    }
-
-    function _isSelectionWithinPDF(selection) {
-      if (selection.rangeCount === 0) {
-        return false
-      }
-      const selectionAncestorNode =
-        selection.getRangeAt(0).commonAncestorContainer
-      return (
-        element.find(selectionAncestorNode).length > 0 ||
-        element.is(selectionAncestorNode)
-      )
-    }
-
-    element.on('scroll', function () {
-      // console.log 'scroll event', element.scrollTop(), 'adjusting?', scope.adjustingScroll
-      // scope.scrollPosition = element.scrollTop()
-      if (scope.adjustingScroll) {
-        renderVisiblePages()
-        scope.adjustingScroll = false
-        return
-      }
-      if (scope.scrollHandlerTimeout) {
-        clearTimeout(scope.scrollHandlerTimeout)
-      }
-      return (scope.scrollHandlerTimeout = setTimeout(scrollHandler, 25))
-    })
-
-    function scrollHandler() {
-      renderVisiblePages()
-      const newPosition = ctrl.getPdfPosition()
-      if (newPosition != null) {
-        scope.position = newPosition
-      }
-      return (scope.scrollHandlerTimeout = null)
-    }
-
-    scope.$watch('pdfSrc', function (newVal, oldVal) {
-      // console.log 'loading pdf', newVal, oldVal
-      if (newVal == null) {
-        return
-      }
-      scope.loadCount = 0 // new pdf, so reset load count
-      scope.loadSuccess = false
-      return ctrl
-        .load()
-        .then(
-          () =>
-            // trigger a redraw
-            (scope.scale = angular.copy(scope.scale))
-        )
-        .catch(error => scope.$emit('pdf:error', error))
-    })
-
-    scope.$watch('scale', function (newVal, oldVal) {
-      // no need to set scale when initialising, done in pdfSrc
-      if (newVal === oldVal) {
-        return
-      }
-      // console.log 'XXX calling Setscale in scale watch'
-      return queueRescale(newVal)
-    })
-
-    scope.$watch('forceScale', function (newVal, oldVal) {
-      // console.log 'got change in numscale watcher', newVal, oldVal
-      if (newVal == null) {
-        return
-      }
-      return queueRescale(newVal)
-    })
-
-    //				scope.$watch 'position', (newVal, oldVal) ->
-    //					console.log 'got change in position watcher', newVal, oldVal
-
-    scope.$watch('forceCheck', function (newVal, oldVal) {
-      // console.log 'forceCheck', newVal, oldVal
-      if (newVal == null) {
-        return
-      }
-      scope.adjustingScroll = true // temporarily disable scroll
-      return queueRescale(scope.scale)
-    })
-
-    scope.$watch(
-      'parentSize',
-      function (newVal, oldVal) {
-        // console.log 'XXX in parentSize watch', newVal, oldVal
-        // if newVal == oldVal
-        // 	console.log 'returning because old and new are the same'
-        // 	return
-        // return unless oldVal?
-        // console.log 'XXX calling setScale in parentSize watcher'
-        if (newVal == null) {
-          return
-        }
-        return queueRescale(scope.scale)
-      },
-      true
-    )
-
-    // scope.$watch 'elementWidth', (newVal, oldVal) ->
-    // 	console.log '*** watch INTERVAL element width is', newVal, oldVal
-
-    scope.$watch('pleaseScrollTo', function (newVal, oldVal) {
-      // console.log 'got request to ScrollTo', newVal, 'oldVal', oldVal
-      if (newVal == null) {
-        return
-      }
-      scope.adjustingScroll = true // temporarily disable scroll
-      // handler while we reposition
-      $(element).scrollTop(newVal)
-      return (scope.pleaseScrollTo = undefined)
-    })
-
-    scope.$watch('pleaseJumpTo', function (newPosition, oldPosition) {
-      // console.log 'in pleaseJumpTo', newPosition, oldPosition
-      if (newPosition == null) {
-        return
-      }
-      return ctrl.setPdfPosition(scope.pages[newPosition.page - 1], newPosition)
-    })
-
-    scope.$watch('navigateTo', function (newVal, oldVal) {
-      if (newVal == null) {
-        return
-      }
-      // console.log 'got request to navigate to', newVal, 'oldVal', oldVal
-      scope.navigateTo = undefined
-      // console.log 'navigate to', newVal
-      // console.log 'look up page num'
-      return scope.document.getDestination(newVal.dest).then(r =>
-        // console.log 'need to go to', r
-        // console.log 'page ref is', r[0]
-        scope.document.getPageIndex(r[0]).then(function (pidx) {
-          // console.log 'page num is', pidx
-          const page = scope.pages[pidx]
-          return scope.document
-            .getPdfViewport(page.pageNum)
-            .then(function (viewport) {
-              // console.log 'got viewport', viewport
-              const coords = viewport.convertToViewportPoint(r[2], r[3])
-              // console.log	'viewport position', coords
-              // console.log 'r is', r, 'r[1]', r[1], 'r[1].name', r[1].name
-              if (r[1].name === 'XYZ') {
-                // console.log 'XYZ:', r[2], r[3]
-                const newPosition = {
-                  page: pidx,
-                  offset: { top: r[3], left: r[2] },
-                }
-                return ctrl.setPdfPosition(scope.pages[pidx], newPosition)
-              }
-            })
-        })
-      )
-    }) // XXX?
-
-    scope.$watch('highlights', function (areas) {
-      // console.log 'got HIGHLIGHTS in pdfViewer', areas
-      if (areas == null) {
-        return
-      }
-      // console.log 'areas are', areas
-      const highlights = Array.from(areas || []).map(area => ({
-        page: area.page - 1,
-        highlight: {
-          left: area.h,
-          top: area.v,
-          height: area.height,
-          width: area.width,
-        },
-      }))
-      // console.log 'highlights', highlights
-
-      if (!highlights.length) {
-        return
-      }
-
-      scope.$broadcast('pdf:highlights', areas)
-
-      const first = highlights[0]
-
-      // switching between split and full pdf views can cause
-      // highlights to appear before rendering
-      if (!scope.pages) {
-        return // ignore highlight scroll if still rendering
-      }
-
-      const pageNum =
-        scope.pages[first.page] != null
-          ? scope.pages[first.page].pageNum
-          : undefined
-
-      if (pageNum == null) {
-        return // ignore highlight scroll if page not found
-      }
-
-      // use a visual offset of 72pt to match the offset in PdfController syncToCode
-      return scope.document.getPdfViewport(pageNum).then(function (viewport) {
-        const position = {
-          page: first.page,
-          offset: {
-            left: first.highlight.left,
-            top:
-              viewport.viewBox[3] -
-              first.highlight.top +
-              first.highlight.height +
-              72,
-          },
-        }
-        return ctrl.setPdfPosition(scope.pages[first.page], position)
-      })
-    })
-
-    return scope.$on('$destroy', function () {
-      // console.log 'handle pdfng directive destroy'
-      if (elementTimer != null) {
-        clearTimeout(elementTimer)
-      }
-      if (layoutTimer != null) {
-        clearTimeout(layoutTimer)
-      }
-      if (rescaleTimer != null) {
-        clearTimeout(rescaleTimer)
-      }
-      if (spinnerTimer != null) {
-        return clearTimeout(spinnerTimer)
-      }
-    })
-  },
-}))
-
-function __range__(left, right, inclusive) {
-  const range = []
-  const ascending = left < right
-  const end = !inclusive ? right : ascending ? right + 1 : right - 1
-  for (let i = left; ascending ? i < end : i > end; ascending ? i++ : i--) {
-    range.push(i)
-  }
-  return range
-}
-function __guard__(value, transform) {
-  return typeof value !== 'undefined' && value !== null
-    ? transform(value)
-    : undefined
-}

services/web/frontend/js/shared/context/compile-context.js

@@ -199,9 +199,7 @@ export function CompileProvider({ children }) {
 
   // pass the "uncompiled" value up into the scope for use outside this context provider
   useEffect(() => {
-    if (window.showNewPdfPreview) {
-      setUncompiled(changedAt > 0)
-    }
+    setUncompiled(changedAt > 0)
   }, [setUncompiled, changedAt])
 
   // always compile the PDF once after opening the project, after the doc has loaded

services/web/frontend/js/vendor/libs/pdfjs-dist/CHANGELOG.md

@@ -1,52 +0,0 @@
-# 2021-07-05
-
-For https://github.com/overleaf/issues/issues/4503#issuecomment-873961735
-
-#### Fork base
-
-Based on v2.2.228 (d7afb74a6e1980da5041f376e7a7c7caef5f42ea)
-
-#### Changes:
-
-- fix handling of fetch errors (9826c6eb1ecd501ac3eb1e9d9a98a3e6edde3fd0)
-- do not bundle NodeJS stream backend (6d118ec35e6e6f954938a485178748f1bb8bdd8a)
-
-#### Reproducing of artifacts
-
-- NodeJS v10.23.3 in docker
-- npm v6.14.11 in docker
-- `pdf.js$ npm ci`
-- `pdf.js$ npx gulp generic`
-- `pdf.js$ cp build/generic/build/pdf.* build/generic/LICENSE HERE/build`
-
-#### Testing
-
-PDF.JS does not properly handle network errors for range requests. Any of the initial probe request or following chunk requests can get the editor stuck.
-
-Once any of the requests has failed, the current pdf.js document is stuck and it's (loading) promise never resolves/rejects. This is in turn breaking the frontend cleanup ahead of switching the pdf. New successful compiles will get queued on top of the stuck promise.
-
-https://github.com/overleaf/web-internal/blob/9ed96cd93d3c4d3b23ff223c658ce80bc895484a/frontend/js/ide/pdfng/directives/pdfRenderer.js#L549-L552
-
-https://github.com/overleaf/web-internal/blob/9ed96cd93d3c4d3b23ff223c658ce80bc895484a/frontend/js/ide/pdfng/directives/pdfViewer.js#L46-L47
-
-Steps to reproduce:
-
-### old (and new) logs ui
-
-- set network speed to something very slow (the chrome dev-tools allow custom profiles, set 1kb/s up/down and 1s latency)
-- wait for the compile response to arrive (see new pending requests for log/pdf)
-- trigger a clear cache in another browser tab
-- resume fast network speed
-
-### new logs ui
-
-- open dropdown of (re-)compile button
-- set network speed to something very slow
-- wait for the compile response to arrive (see new pending requests for log/pdf)
-- click re-compile from scratch (which shifts over the stop compile open of the dropdown)
-- resume fast network speed
-
-Alternative reproduction steps involving hacking the ssl-proxy:
-
-- https://digital-science.slack.com/archives/C0216GDEG9L/p1625240302143900
-- https://digital-science.slack.com/archives/C0216GDEG9L/p1625238107141300

services/web/frontend/js/vendor/libs/pdfjs-dist/build/LICENSE

@@ -1,177 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS

services/web/frontend/js/vendor/libs/pdfjs-dist/build/pdf.js

@@ -1,23967 +0,0 @@
-/**
- * @licstart The following is the entire license notice for the
- * Javascript code in this page
- *
- * Copyright 2019 Mozilla Foundation
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- *
- * @licend The above is the entire license notice for the
- * Javascript code in this page
- */
-
-(function webpackUniversalModuleDefinition(root, factory) {
-	if(typeof exports === 'object' && typeof module === 'object')
-		module.exports = factory();
-	else if(typeof define === 'function' && define.amd)
-		define("pdfjs-dist/build/pdf", [], factory);
-	else if(typeof exports === 'object')
-		exports["pdfjs-dist/build/pdf"] = factory();
-	else
-		root["pdfjs-dist/build/pdf"] = root.pdfjsLib = factory();
-})(this, function() {
-return /******/ (function(modules) { // webpackBootstrap
-/******/ 	// The module cache
-/******/ 	var installedModules = {};
-/******/
-/******/ 	// The require function
-/******/ 	function __w_pdfjs_require__(moduleId) {
-/******/
-/******/ 		// Check if module is in cache
-/******/ 		if(installedModules[moduleId]) {
-/******/ 			return installedModules[moduleId].exports;
-/******/ 		}
-/******/ 		// Create a new module (and put it into the cache)
-/******/ 		var module = installedModules[moduleId] = {
-/******/ 			i: moduleId,
-/******/ 			l: false,
-/******/ 			exports: {}
-/******/ 		};
-/******/
-/******/ 		// Execute the module function
-/******/ 		modules[moduleId].call(module.exports, module, module.exports, __w_pdfjs_require__);
-/******/
-/******/ 		// Flag the module as loaded
-/******/ 		module.l = true;
-/******/
-/******/ 		// Return the exports of the module
-/******/ 		return module.exports;
-/******/ 	}
-/******/
-/******/
-/******/ 	// expose the modules object (__webpack_modules__)
-/******/ 	__w_pdfjs_require__.m = modules;
-/******/
-/******/ 	// expose the module cache
-/******/ 	__w_pdfjs_require__.c = installedModules;
-/******/
-/******/ 	// define getter function for harmony exports
-/******/ 	__w_pdfjs_require__.d = function(exports, name, getter) {
-/******/ 		if(!__w_pdfjs_require__.o(exports, name)) {
-/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
-/******/ 		}
-/******/ 	};
-/******/
-/******/ 	// define __esModule on exports
-/******/ 	__w_pdfjs_require__.r = function(exports) {
-/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
-/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
-/******/ 		}
-/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
-/******/ 	};
-/******/
-/******/ 	// create a fake namespace object
-/******/ 	// mode & 1: value is a module id, require it
-/******/ 	// mode & 2: merge all properties of value into the ns
-/******/ 	// mode & 4: return value when already ns object
-/******/ 	// mode & 8|1: behave like require
-/******/ 	__w_pdfjs_require__.t = function(value, mode) {
-/******/ 		if(mode & 1) value = __w_pdfjs_require__(value);
-/******/ 		if(mode & 8) return value;
-/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
-/******/ 		var ns = Object.create(null);
-/******/ 		__w_pdfjs_require__.r(ns);
-/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
-/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __w_pdfjs_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
-/******/ 		return ns;
-/******/ 	};
-/******/
-/******/ 	// getDefaultExport function for compatibility with non-harmony modules
-/******/ 	__w_pdfjs_require__.n = function(module) {
-/******/ 		var getter = module && module.__esModule ?
-/******/ 			function getDefault() { return module['default']; } :
-/******/ 			function getModuleExports() { return module; };
-/******/ 		__w_pdfjs_require__.d(getter, 'a', getter);
-/******/ 		return getter;
-/******/ 	};
-/******/
-/******/ 	// Object.prototype.hasOwnProperty.call
-/******/ 	__w_pdfjs_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
-/******/
-/******/ 	// __webpack_public_path__
-/******/ 	__w_pdfjs_require__.p = "";
-/******/
-/******/
-/******/ 	// Load entry module and return exports
-/******/ 	return __w_pdfjs_require__(__w_pdfjs_require__.s = 0);
-/******/ })
-/************************************************************************/
-/******/ ([
-/* 0 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var pdfjsVersion = '2.2.230';
-var pdfjsBuild = '6d118ec35';
-
-var pdfjsSharedUtil = __w_pdfjs_require__(1);
-
-var pdfjsDisplayAPI = __w_pdfjs_require__(147);
-
-var pdfjsDisplayTextLayer = __w_pdfjs_require__(162);
-
-var pdfjsDisplayAnnotationLayer = __w_pdfjs_require__(163);
-
-var pdfjsDisplayDisplayUtils = __w_pdfjs_require__(151);
-
-var pdfjsDisplaySVG = __w_pdfjs_require__(164);
-
-var pdfjsDisplayWorkerOptions = __w_pdfjs_require__(156);
-
-var pdfjsDisplayAPICompatibility = __w_pdfjs_require__(153);
-
-{
-  var isNodeJS = __w_pdfjs_require__(4);
-
-  if (!isNodeJS()) {
-    var PDFNetworkStream = __w_pdfjs_require__(165).PDFNetworkStream;
-
-    var PDFFetchStream;
-
-    if (pdfjsDisplayDisplayUtils.isFetchSupported()) {
-      PDFFetchStream = __w_pdfjs_require__(168).PDFFetchStream;
-    }
-
-    pdfjsDisplayAPI.setPDFNetworkStreamFactory(function (params) {
-      if (PDFFetchStream && pdfjsDisplayDisplayUtils.isValidFetchUrl(params.url)) {
-        return new PDFFetchStream(params);
-      }
-
-      return new PDFNetworkStream(params);
-    });
-  }
-}
-exports.build = pdfjsDisplayAPI.build;
-exports.version = pdfjsDisplayAPI.version;
-exports.getDocument = pdfjsDisplayAPI.getDocument;
-exports.LoopbackPort = pdfjsDisplayAPI.LoopbackPort;
-exports.PDFDataRangeTransport = pdfjsDisplayAPI.PDFDataRangeTransport;
-exports.PDFWorker = pdfjsDisplayAPI.PDFWorker;
-exports.renderTextLayer = pdfjsDisplayTextLayer.renderTextLayer;
-exports.AnnotationLayer = pdfjsDisplayAnnotationLayer.AnnotationLayer;
-exports.createPromiseCapability = pdfjsSharedUtil.createPromiseCapability;
-exports.PasswordResponses = pdfjsSharedUtil.PasswordResponses;
-exports.InvalidPDFException = pdfjsSharedUtil.InvalidPDFException;
-exports.MissingPDFException = pdfjsSharedUtil.MissingPDFException;
-exports.SVGGraphics = pdfjsDisplaySVG.SVGGraphics;
-exports.NativeImageDecoding = pdfjsSharedUtil.NativeImageDecoding;
-exports.CMapCompressionType = pdfjsSharedUtil.CMapCompressionType;
-exports.PermissionFlag = pdfjsSharedUtil.PermissionFlag;
-exports.UnexpectedResponseException = pdfjsSharedUtil.UnexpectedResponseException;
-exports.OPS = pdfjsSharedUtil.OPS;
-exports.VerbosityLevel = pdfjsSharedUtil.VerbosityLevel;
-exports.UNSUPPORTED_FEATURES = pdfjsSharedUtil.UNSUPPORTED_FEATURES;
-exports.createValidAbsoluteUrl = pdfjsSharedUtil.createValidAbsoluteUrl;
-exports.createObjectURL = pdfjsSharedUtil.createObjectURL;
-exports.removeNullCharacters = pdfjsSharedUtil.removeNullCharacters;
-exports.shadow = pdfjsSharedUtil.shadow;
-exports.Util = pdfjsSharedUtil.Util;
-exports.ReadableStream = pdfjsSharedUtil.ReadableStream;
-exports.URL = pdfjsSharedUtil.URL;
-exports.RenderingCancelledException = pdfjsDisplayDisplayUtils.RenderingCancelledException;
-exports.getFilenameFromUrl = pdfjsDisplayDisplayUtils.getFilenameFromUrl;
-exports.LinkTarget = pdfjsDisplayDisplayUtils.LinkTarget;
-exports.addLinkAttributes = pdfjsDisplayDisplayUtils.addLinkAttributes;
-exports.loadScript = pdfjsDisplayDisplayUtils.loadScript;
-exports.PDFDateString = pdfjsDisplayDisplayUtils.PDFDateString;
-exports.GlobalWorkerOptions = pdfjsDisplayWorkerOptions.GlobalWorkerOptions;
-exports.apiCompatibilityParams = pdfjsDisplayAPICompatibility.apiCompatibilityParams;
-
-/***/ }),
-/* 1 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.arrayByteLength = arrayByteLength;
-exports.arraysToBytes = arraysToBytes;
-exports.assert = assert;
-exports.bytesToString = bytesToString;
-exports.createPromiseCapability = createPromiseCapability;
-exports.getVerbosityLevel = getVerbosityLevel;
-exports.info = info;
-exports.isArrayBuffer = isArrayBuffer;
-exports.isArrayEqual = isArrayEqual;
-exports.isBool = isBool;
-exports.isEmptyObj = isEmptyObj;
-exports.isNum = isNum;
-exports.isString = isString;
-exports.isSpace = isSpace;
-exports.isSameOrigin = isSameOrigin;
-exports.createValidAbsoluteUrl = createValidAbsoluteUrl;
-exports.isLittleEndian = isLittleEndian;
-exports.isEvalSupported = isEvalSupported;
-exports.log2 = log2;
-exports.readInt8 = readInt8;
-exports.readUint16 = readUint16;
-exports.readUint32 = readUint32;
-exports.removeNullCharacters = removeNullCharacters;
-exports.setVerbosityLevel = setVerbosityLevel;
-exports.shadow = shadow;
-exports.string32 = string32;
-exports.stringToBytes = stringToBytes;
-exports.stringToPDFString = stringToPDFString;
-exports.stringToUTF8String = stringToUTF8String;
-exports.utf8StringToString = utf8StringToString;
-exports.warn = warn;
-exports.unreachable = unreachable;
-Object.defineProperty(exports, "ReadableStream", {
-  enumerable: true,
-  get: function get() {
-    return _streams_polyfill.ReadableStream;
-  }
-});
-Object.defineProperty(exports, "URL", {
-  enumerable: true,
-  get: function get() {
-    return _url_polyfill.URL;
-  }
-});
-exports.createObjectURL = exports.FormatError = exports.Util = exports.UnknownErrorException = exports.UnexpectedResponseException = exports.TextRenderingMode = exports.StreamType = exports.PermissionFlag = exports.PasswordResponses = exports.PasswordException = exports.NativeImageDecoding = exports.MissingPDFException = exports.InvalidPDFException = exports.AbortException = exports.CMapCompressionType = exports.ImageKind = exports.FontType = exports.AnnotationType = exports.AnnotationFlag = exports.AnnotationFieldFlag = exports.AnnotationBorderStyleType = exports.UNSUPPORTED_FEATURES = exports.VerbosityLevel = exports.OPS = exports.IDENTITY_MATRIX = exports.FONT_IDENTITY_MATRIX = void 0;
-
-__w_pdfjs_require__(2);
-
-var _streams_polyfill = __w_pdfjs_require__(143);
-
-var _url_polyfill = __w_pdfjs_require__(145);
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-var IDENTITY_MATRIX = [1, 0, 0, 1, 0, 0];
-exports.IDENTITY_MATRIX = IDENTITY_MATRIX;
-var FONT_IDENTITY_MATRIX = [0.001, 0, 0, 0.001, 0, 0];
-exports.FONT_IDENTITY_MATRIX = FONT_IDENTITY_MATRIX;
-var NativeImageDecoding = {
-  NONE: 'none',
-  DECODE: 'decode',
-  DISPLAY: 'display'
-};
-exports.NativeImageDecoding = NativeImageDecoding;
-var PermissionFlag = {
-  PRINT: 0x04,
-  MODIFY_CONTENTS: 0x08,
-  COPY: 0x10,
-  MODIFY_ANNOTATIONS: 0x20,
-  FILL_INTERACTIVE_FORMS: 0x100,
-  COPY_FOR_ACCESSIBILITY: 0x200,
-  ASSEMBLE: 0x400,
-  PRINT_HIGH_QUALITY: 0x800
-};
-exports.PermissionFlag = PermissionFlag;
-var TextRenderingMode = {
-  FILL: 0,
-  STROKE: 1,
-  FILL_STROKE: 2,
-  INVISIBLE: 3,
-  FILL_ADD_TO_PATH: 4,
-  STROKE_ADD_TO_PATH: 5,
-  FILL_STROKE_ADD_TO_PATH: 6,
-  ADD_TO_PATH: 7,
-  FILL_STROKE_MASK: 3,
-  ADD_TO_PATH_FLAG: 4
-};
-exports.TextRenderingMode = TextRenderingMode;
-var ImageKind = {
-  GRAYSCALE_1BPP: 1,
-  RGB_24BPP: 2,
-  RGBA_32BPP: 3
-};
-exports.ImageKind = ImageKind;
-var AnnotationType = {
-  TEXT: 1,
-  LINK: 2,
-  FREETEXT: 3,
-  LINE: 4,
-  SQUARE: 5,
-  CIRCLE: 6,
-  POLYGON: 7,
-  POLYLINE: 8,
-  HIGHLIGHT: 9,
-  UNDERLINE: 10,
-  SQUIGGLY: 11,
-  STRIKEOUT: 12,
-  STAMP: 13,
-  CARET: 14,
-  INK: 15,
-  POPUP: 16,
-  FILEATTACHMENT: 17,
-  SOUND: 18,
-  MOVIE: 19,
-  WIDGET: 20,
-  SCREEN: 21,
-  PRINTERMARK: 22,
-  TRAPNET: 23,
-  WATERMARK: 24,
-  THREED: 25,
-  REDACT: 26
-};
-exports.AnnotationType = AnnotationType;
-var AnnotationFlag = {
-  INVISIBLE: 0x01,
-  HIDDEN: 0x02,
-  PRINT: 0x04,
-  NOZOOM: 0x08,
-  NOROTATE: 0x10,
-  NOVIEW: 0x20,
-  READONLY: 0x40,
-  LOCKED: 0x80,
-  TOGGLENOVIEW: 0x100,
-  LOCKEDCONTENTS: 0x200
-};
-exports.AnnotationFlag = AnnotationFlag;
-var AnnotationFieldFlag = {
-  READONLY: 0x0000001,
-  REQUIRED: 0x0000002,
-  NOEXPORT: 0x0000004,
-  MULTILINE: 0x0001000,
-  PASSWORD: 0x0002000,
-  NOTOGGLETOOFF: 0x0004000,
-  RADIO: 0x0008000,
-  PUSHBUTTON: 0x0010000,
-  COMBO: 0x0020000,
-  EDIT: 0x0040000,
-  SORT: 0x0080000,
-  FILESELECT: 0x0100000,
-  MULTISELECT: 0x0200000,
-  DONOTSPELLCHECK: 0x0400000,
-  DONOTSCROLL: 0x0800000,
-  COMB: 0x1000000,
-  RICHTEXT: 0x2000000,
-  RADIOSINUNISON: 0x2000000,
-  COMMITONSELCHANGE: 0x4000000
-};
-exports.AnnotationFieldFlag = AnnotationFieldFlag;
-var AnnotationBorderStyleType = {
-  SOLID: 1,
-  DASHED: 2,
-  BEVELED: 3,
-  INSET: 4,
-  UNDERLINE: 5
-};
-exports.AnnotationBorderStyleType = AnnotationBorderStyleType;
-var StreamType = {
-  UNKNOWN: 0,
-  FLATE: 1,
-  LZW: 2,
-  DCT: 3,
-  JPX: 4,
-  JBIG: 5,
-  A85: 6,
-  AHX: 7,
-  CCF: 8,
-  RL: 9
-};
-exports.StreamType = StreamType;
-var FontType = {
-  UNKNOWN: 0,
-  TYPE1: 1,
-  TYPE1C: 2,
-  CIDFONTTYPE0: 3,
-  CIDFONTTYPE0C: 4,
-  TRUETYPE: 5,
-  CIDFONTTYPE2: 6,
-  TYPE3: 7,
-  OPENTYPE: 8,
-  TYPE0: 9,
-  MMTYPE1: 10
-};
-exports.FontType = FontType;
-var VerbosityLevel = {
-  ERRORS: 0,
-  WARNINGS: 1,
-  INFOS: 5
-};
-exports.VerbosityLevel = VerbosityLevel;
-var CMapCompressionType = {
-  NONE: 0,
-  BINARY: 1,
-  STREAM: 2
-};
-exports.CMapCompressionType = CMapCompressionType;
-var OPS = {
-  dependency: 1,
-  setLineWidth: 2,
-  setLineCap: 3,
-  setLineJoin: 4,
-  setMiterLimit: 5,
-  setDash: 6,
-  setRenderingIntent: 7,
-  setFlatness: 8,
-  setGState: 9,
-  save: 10,
-  restore: 11,
-  transform: 12,
-  moveTo: 13,
-  lineTo: 14,
-  curveTo: 15,
-  curveTo2: 16,
-  curveTo3: 17,
-  closePath: 18,
-  rectangle: 19,
-  stroke: 20,
-  closeStroke: 21,
-  fill: 22,
-  eoFill: 23,
-  fillStroke: 24,
-  eoFillStroke: 25,
-  closeFillStroke: 26,
-  closeEOFillStroke: 27,
-  endPath: 28,
-  clip: 29,
-  eoClip: 30,
-  beginText: 31,
-  endText: 32,
-  setCharSpacing: 33,
-  setWordSpacing: 34,
-  setHScale: 35,
-  setLeading: 36,
-  setFont: 37,
-  setTextRenderingMode: 38,
-  setTextRise: 39,
-  moveText: 40,
-  setLeadingMoveText: 41,
-  setTextMatrix: 42,
-  nextLine: 43,
-  showText: 44,
-  showSpacedText: 45,
-  nextLineShowText: 46,
-  nextLineSetSpacingShowText: 47,
-  setCharWidth: 48,
-  setCharWidthAndBounds: 49,
-  setStrokeColorSpace: 50,
-  setFillColorSpace: 51,
-  setStrokeColor: 52,
-  setStrokeColorN: 53,
-  setFillColor: 54,
-  setFillColorN: 55,
-  setStrokeGray: 56,
-  setFillGray: 57,
-  setStrokeRGBColor: 58,
-  setFillRGBColor: 59,
-  setStrokeCMYKColor: 60,
-  setFillCMYKColor: 61,
-  shadingFill: 62,
-  beginInlineImage: 63,
-  beginImageData: 64,
-  endInlineImage: 65,
-  paintXObject: 66,
-  markPoint: 67,
-  markPointProps: 68,
-  beginMarkedContent: 69,
-  beginMarkedContentProps: 70,
-  endMarkedContent: 71,
-  beginCompat: 72,
-  endCompat: 73,
-  paintFormXObjectBegin: 74,
-  paintFormXObjectEnd: 75,
-  beginGroup: 76,
-  endGroup: 77,
-  beginAnnotations: 78,
-  endAnnotations: 79,
-  beginAnnotation: 80,
-  endAnnotation: 81,
-  paintJpegXObject: 82,
-  paintImageMaskXObject: 83,
-  paintImageMaskXObjectGroup: 84,
-  paintImageXObject: 85,
-  paintInlineImageXObject: 86,
-  paintInlineImageXObjectGroup: 87,
-  paintImageXObjectRepeat: 88,
-  paintImageMaskXObjectRepeat: 89,
-  paintSolidColorImageMask: 90,
-  constructPath: 91
-};
-exports.OPS = OPS;
-var UNSUPPORTED_FEATURES = {
-  unknown: 'unknown',
-  forms: 'forms',
-  javaScript: 'javaScript',
-  smask: 'smask',
-  shadingPattern: 'shadingPattern',
-  font: 'font'
-};
-exports.UNSUPPORTED_FEATURES = UNSUPPORTED_FEATURES;
-var PasswordResponses = {
-  NEED_PASSWORD: 1,
-  INCORRECT_PASSWORD: 2
-};
-exports.PasswordResponses = PasswordResponses;
-var verbosity = VerbosityLevel.WARNINGS;
-
-function setVerbosityLevel(level) {
-  if (Number.isInteger(level)) {
-    verbosity = level;
-  }
-}
-
-function getVerbosityLevel() {
-  return verbosity;
-}
-
-function info(msg) {
-  if (verbosity >= VerbosityLevel.INFOS) {
-    console.log('Info: ' + msg);
-  }
-}
-
-function warn(msg) {
-  if (verbosity >= VerbosityLevel.WARNINGS) {
-    console.log('Warning: ' + msg);
-  }
-}
-
-function unreachable(msg) {
-  throw new Error(msg);
-}
-
-function assert(cond, msg) {
-  if (!cond) {
-    unreachable(msg);
-  }
-}
-
-function isSameOrigin(baseUrl, otherUrl) {
-  try {
-    var base = new _url_polyfill.URL(baseUrl);
-
-    if (!base.origin || base.origin === 'null') {
-      return false;
-    }
-  } catch (e) {
-    return false;
-  }
-
-  var other = new _url_polyfill.URL(otherUrl, base);
-  return base.origin === other.origin;
-}
-
-function _isValidProtocol(url) {
-  if (!url) {
-    return false;
-  }
-
-  switch (url.protocol) {
-    case 'http:':
-    case 'https:':
-    case 'ftp:':
-    case 'mailto:':
-    case 'tel:':
-      return true;
-
-    default:
-      return false;
-  }
-}
-
-function createValidAbsoluteUrl(url, baseUrl) {
-  if (!url) {
-    return null;
-  }
-
-  try {
-    var absoluteUrl = baseUrl ? new _url_polyfill.URL(url, baseUrl) : new _url_polyfill.URL(url);
-
-    if (_isValidProtocol(absoluteUrl)) {
-      return absoluteUrl;
-    }
-  } catch (ex) {}
-
-  return null;
-}
-
-function shadow(obj, prop, value) {
-  Object.defineProperty(obj, prop, {
-    value: value,
-    enumerable: true,
-    configurable: true,
-    writable: false
-  });
-  return value;
-}
-
-var PasswordException = function PasswordExceptionClosure() {
-  function PasswordException(msg, code) {
-    this.name = 'PasswordException';
-    this.message = msg;
-    this.code = code;
-  }
-
-  PasswordException.prototype = new Error();
-  PasswordException.constructor = PasswordException;
-  return PasswordException;
-}();
-
-exports.PasswordException = PasswordException;
-
-var UnknownErrorException = function UnknownErrorExceptionClosure() {
-  function UnknownErrorException(msg, details) {
-    this.name = 'UnknownErrorException';
-    this.message = msg;
-    this.details = details;
-  }
-
-  UnknownErrorException.prototype = new Error();
-  UnknownErrorException.constructor = UnknownErrorException;
-  return UnknownErrorException;
-}();
-
-exports.UnknownErrorException = UnknownErrorException;
-
-var InvalidPDFException = function InvalidPDFExceptionClosure() {
-  function InvalidPDFException(msg) {
-    this.name = 'InvalidPDFException';
-    this.message = msg;
-  }
-
-  InvalidPDFException.prototype = new Error();
-  InvalidPDFException.constructor = InvalidPDFException;
-  return InvalidPDFException;
-}();
-
-exports.InvalidPDFException = InvalidPDFException;
-
-var MissingPDFException = function MissingPDFExceptionClosure() {
-  function MissingPDFException(msg) {
-    this.name = 'MissingPDFException';
-    this.message = msg;
-  }
-
-  MissingPDFException.prototype = new Error();
-  MissingPDFException.constructor = MissingPDFException;
-  return MissingPDFException;
-}();
-
-exports.MissingPDFException = MissingPDFException;
-
-var UnexpectedResponseException = function UnexpectedResponseExceptionClosure() {
-  function UnexpectedResponseException(msg, status) {
-    this.name = 'UnexpectedResponseException';
-    this.message = msg;
-    this.status = status;
-  }
-
-  UnexpectedResponseException.prototype = new Error();
-  UnexpectedResponseException.constructor = UnexpectedResponseException;
-  return UnexpectedResponseException;
-}();
-
-exports.UnexpectedResponseException = UnexpectedResponseException;
-
-var FormatError = function FormatErrorClosure() {
-  function FormatError(msg) {
-    this.message = msg;
-  }
-
-  FormatError.prototype = new Error();
-  FormatError.prototype.name = 'FormatError';
-  FormatError.constructor = FormatError;
-  return FormatError;
-}();
-
-exports.FormatError = FormatError;
-
-var AbortException = function AbortExceptionClosure() {
-  function AbortException(msg) {
-    this.name = 'AbortException';
-    this.message = msg;
-  }
-
-  AbortException.prototype = new Error();
-  AbortException.constructor = AbortException;
-  return AbortException;
-}();
-
-exports.AbortException = AbortException;
-var NullCharactersRegExp = /\x00/g;
-
-function removeNullCharacters(str) {
-  if (typeof str !== 'string') {
-    warn('The argument for removeNullCharacters must be a string.');
-    return str;
-  }
-
-  return str.replace(NullCharactersRegExp, '');
-}
-
-function bytesToString(bytes) {
-  assert(bytes !== null && _typeof(bytes) === 'object' && bytes.length !== undefined, 'Invalid argument for bytesToString');
-  var length = bytes.length;
-  var MAX_ARGUMENT_COUNT = 8192;
-
-  if (length < MAX_ARGUMENT_COUNT) {
-    return String.fromCharCode.apply(null, bytes);
-  }
-
-  var strBuf = [];
-
-  for (var i = 0; i < length; i += MAX_ARGUMENT_COUNT) {
-    var chunkEnd = Math.min(i + MAX_ARGUMENT_COUNT, length);
-    var chunk = bytes.subarray(i, chunkEnd);
-    strBuf.push(String.fromCharCode.apply(null, chunk));
-  }
-
-  return strBuf.join('');
-}
-
-function stringToBytes(str) {
-  assert(typeof str === 'string', 'Invalid argument for stringToBytes');
-  var length = str.length;
-  var bytes = new Uint8Array(length);
-
-  for (var i = 0; i < length; ++i) {
-    bytes[i] = str.charCodeAt(i) & 0xFF;
-  }
-
-  return bytes;
-}
-
-function arrayByteLength(arr) {
-  if (arr.length !== undefined) {
-    return arr.length;
-  }
-
-  assert(arr.byteLength !== undefined);
-  return arr.byteLength;
-}
-
-function arraysToBytes(arr) {
-  if (arr.length === 1 && arr[0] instanceof Uint8Array) {
-    return arr[0];
-  }
-
-  var resultLength = 0;
-  var i,
-      ii = arr.length;
-  var item, itemLength;
-
-  for (i = 0; i < ii; i++) {
-    item = arr[i];
-    itemLength = arrayByteLength(item);
-    resultLength += itemLength;
-  }
-
-  var pos = 0;
-  var data = new Uint8Array(resultLength);
-
-  for (i = 0; i < ii; i++) {
-    item = arr[i];
-
-    if (!(item instanceof Uint8Array)) {
-      if (typeof item === 'string') {
-        item = stringToBytes(item);
-      } else {
-        item = new Uint8Array(item);
-      }
-    }
-
-    itemLength = item.byteLength;
-    data.set(item, pos);
-    pos += itemLength;
-  }
-
-  return data;
-}
-
-function string32(value) {
-  return String.fromCharCode(value >> 24 & 0xff, value >> 16 & 0xff, value >> 8 & 0xff, value & 0xff);
-}
-
-function log2(x) {
-  if (x <= 0) {
-    return 0;
-  }
-
-  return Math.ceil(Math.log2(x));
-}
-
-function readInt8(data, start) {
-  return data[start] << 24 >> 24;
-}
-
-function readUint16(data, offset) {
-  return data[offset] << 8 | data[offset + 1];
-}
-
-function readUint32(data, offset) {
-  return (data[offset] << 24 | data[offset + 1] << 16 | data[offset + 2] << 8 | data[offset + 3]) >>> 0;
-}
-
-function isLittleEndian() {
-  var buffer8 = new Uint8Array(4);
-  buffer8[0] = 1;
-  var view32 = new Uint32Array(buffer8.buffer, 0, 1);
-  return view32[0] === 1;
-}
-
-function isEvalSupported() {
-  try {
-    new Function('');
-    return true;
-  } catch (e) {
-    return false;
-  }
-}
-
-var Util = function UtilClosure() {
-  function Util() {}
-
-  var rgbBuf = ['rgb(', 0, ',', 0, ',', 0, ')'];
-
-  Util.makeCssRgb = function Util_makeCssRgb(r, g, b) {
-    rgbBuf[1] = r;
-    rgbBuf[3] = g;
-    rgbBuf[5] = b;
-    return rgbBuf.join('');
-  };
-
-  Util.transform = function Util_transform(m1, m2) {
-    return [m1[0] * m2[0] + m1[2] * m2[1], m1[1] * m2[0] + m1[3] * m2[1], m1[0] * m2[2] + m1[2] * m2[3], m1[1] * m2[2] + m1[3] * m2[3], m1[0] * m2[4] + m1[2] * m2[5] + m1[4], m1[1] * m2[4] + m1[3] * m2[5] + m1[5]];
-  };
-
-  Util.applyTransform = function Util_applyTransform(p, m) {
-    var xt = p[0] * m[0] + p[1] * m[2] + m[4];
-    var yt = p[0] * m[1] + p[1] * m[3] + m[5];
-    return [xt, yt];
-  };
-
-  Util.applyInverseTransform = function Util_applyInverseTransform(p, m) {
-    var d = m[0] * m[3] - m[1] * m[2];
-    var xt = (p[0] * m[3] - p[1] * m[2] + m[2] * m[5] - m[4] * m[3]) / d;
-    var yt = (-p[0] * m[1] + p[1] * m[0] + m[4] * m[1] - m[5] * m[0]) / d;
-    return [xt, yt];
-  };
-
-  Util.getAxialAlignedBoundingBox = function Util_getAxialAlignedBoundingBox(r, m) {
-    var p1 = Util.applyTransform(r, m);
-    var p2 = Util.applyTransform(r.slice(2, 4), m);
-    var p3 = Util.applyTransform([r[0], r[3]], m);
-    var p4 = Util.applyTransform([r[2], r[1]], m);
-    return [Math.min(p1[0], p2[0], p3[0], p4[0]), Math.min(p1[1], p2[1], p3[1], p4[1]), Math.max(p1[0], p2[0], p3[0], p4[0]), Math.max(p1[1], p2[1], p3[1], p4[1])];
-  };
-
-  Util.inverseTransform = function Util_inverseTransform(m) {
-    var d = m[0] * m[3] - m[1] * m[2];
-    return [m[3] / d, -m[1] / d, -m[2] / d, m[0] / d, (m[2] * m[5] - m[4] * m[3]) / d, (m[4] * m[1] - m[5] * m[0]) / d];
-  };
-
-  Util.apply3dTransform = function Util_apply3dTransform(m, v) {
-    return [m[0] * v[0] + m[1] * v[1] + m[2] * v[2], m[3] * v[0] + m[4] * v[1] + m[5] * v[2], m[6] * v[0] + m[7] * v[1] + m[8] * v[2]];
-  };
-
-  Util.singularValueDecompose2dScale = function Util_singularValueDecompose2dScale(m) {
-    var transpose = [m[0], m[2], m[1], m[3]];
-    var a = m[0] * transpose[0] + m[1] * transpose[2];
-    var b = m[0] * transpose[1] + m[1] * transpose[3];
-    var c = m[2] * transpose[0] + m[3] * transpose[2];
-    var d = m[2] * transpose[1] + m[3] * transpose[3];
-    var first = (a + d) / 2;
-    var second = Math.sqrt((a + d) * (a + d) - 4 * (a * d - c * b)) / 2;
-    var sx = first + second || 1;
-    var sy = first - second || 1;
-    return [Math.sqrt(sx), Math.sqrt(sy)];
-  };
-
-  Util.normalizeRect = function Util_normalizeRect(rect) {
-    var r = rect.slice(0);
-
-    if (rect[0] > rect[2]) {
-      r[0] = rect[2];
-      r[2] = rect[0];
-    }
-
-    if (rect[1] > rect[3]) {
-      r[1] = rect[3];
-      r[3] = rect[1];
-    }
-
-    return r;
-  };
-
-  Util.intersect = function Util_intersect(rect1, rect2) {
-    function compare(a, b) {
-      return a - b;
-    }
-
-    var orderedX = [rect1[0], rect1[2], rect2[0], rect2[2]].sort(compare),
-        orderedY = [rect1[1], rect1[3], rect2[1], rect2[3]].sort(compare),
-        result = [];
-    rect1 = Util.normalizeRect(rect1);
-    rect2 = Util.normalizeRect(rect2);
-
-    if (orderedX[0] === rect1[0] && orderedX[1] === rect2[0] || orderedX[0] === rect2[0] && orderedX[1] === rect1[0]) {
-      result[0] = orderedX[1];
-      result[2] = orderedX[2];
-    } else {
-      return false;
-    }
-
-    if (orderedY[0] === rect1[1] && orderedY[1] === rect2[1] || orderedY[0] === rect2[1] && orderedY[1] === rect1[1]) {
-      result[1] = orderedY[1];
-      result[3] = orderedY[2];
-    } else {
-      return false;
-    }
-
-    return result;
-  };
-
-  return Util;
-}();
-
-exports.Util = Util;
-var PDFStringTranslateTable = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2D8, 0x2C7, 0x2C6, 0x2D9, 0x2DD, 0x2DB, 0x2DA, 0x2DC, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x2022, 0x2020, 0x2021, 0x2026, 0x2014, 0x2013, 0x192, 0x2044, 0x2039, 0x203A, 0x2212, 0x2030, 0x201E, 0x201C, 0x201D, 0x2018, 0x2019, 0x201A, 0x2122, 0xFB01, 0xFB02, 0x141, 0x152, 0x160, 0x178, 0x17D, 0x131, 0x142, 0x153, 0x161, 0x17E, 0, 0x20AC];
-
-function stringToPDFString(str) {
-  var i,
-      n = str.length,
-      strBuf = [];
-
-  if (str[0] === '\xFE' && str[1] === '\xFF') {
-    for (i = 2; i < n; i += 2) {
-      strBuf.push(String.fromCharCode(str.charCodeAt(i) << 8 | str.charCodeAt(i + 1)));
-    }
-  } else {
-    for (i = 0; i < n; ++i) {
-      var code = PDFStringTranslateTable[str.charCodeAt(i)];
-      strBuf.push(code ? String.fromCharCode(code) : str.charAt(i));
-    }
-  }
-
-  return strBuf.join('');
-}
-
-function stringToUTF8String(str) {
-  return decodeURIComponent(escape(str));
-}
-
-function utf8StringToString(str) {
-  return unescape(encodeURIComponent(str));
-}
-
-function isEmptyObj(obj) {
-  for (var key in obj) {
-    return false;
-  }
-
-  return true;
-}
-
-function isBool(v) {
-  return typeof v === 'boolean';
-}
-
-function isNum(v) {
-  return typeof v === 'number';
-}
-
-function isString(v) {
-  return typeof v === 'string';
-}
-
-function isArrayBuffer(v) {
-  return _typeof(v) === 'object' && v !== null && v.byteLength !== undefined;
-}
-
-function isArrayEqual(arr1, arr2) {
-  if (arr1.length !== arr2.length) {
-    return false;
-  }
-
-  return arr1.every(function (element, index) {
-    return element === arr2[index];
-  });
-}
-
-function isSpace(ch) {
-  return ch === 0x20 || ch === 0x09 || ch === 0x0D || ch === 0x0A;
-}
-
-function createPromiseCapability() {
-  var capability = Object.create(null);
-  var isSettled = false;
-  Object.defineProperty(capability, 'settled', {
-    get: function get() {
-      return isSettled;
-    }
-  });
-  capability.promise = new Promise(function (resolve, reject) {
-    capability.resolve = function (data) {
-      isSettled = true;
-      resolve(data);
-    };
-
-    capability.reject = function (reason) {
-      isSettled = true;
-      reject(reason);
-    };
-  });
-  return capability;
-}
-
-var createObjectURL = function createObjectURLClosure() {
-  var digits = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
-  return function createObjectURL(data, contentType) {
-    var forceDataSchema = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-
-    if (!forceDataSchema && _url_polyfill.URL.createObjectURL) {
-      var blob = new Blob([data], {
-        type: contentType
-      });
-      return _url_polyfill.URL.createObjectURL(blob);
-    }
-
-    var buffer = 'data:' + contentType + ';base64,';
-
-    for (var i = 0, ii = data.length; i < ii; i += 3) {
-      var b1 = data[i] & 0xFF;
-      var b2 = data[i + 1] & 0xFF;
-      var b3 = data[i + 2] & 0xFF;
-      var d1 = b1 >> 2,
-          d2 = (b1 & 3) << 4 | b2 >> 4;
-      var d3 = i + 1 < ii ? (b2 & 0xF) << 2 | b3 >> 6 : 64;
-      var d4 = i + 2 < ii ? b3 & 0x3F : 64;
-      buffer += digits[d1] + digits[d2] + digits[d3] + digits[d4];
-    }
-
-    return buffer;
-  };
-}();
-
-exports.createObjectURL = createObjectURL;
-
-/***/ }),
-/* 2 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-var globalScope = __w_pdfjs_require__(3);
-
-if (!globalScope._pdfjsCompatibilityChecked) {
-  globalScope._pdfjsCompatibilityChecked = true;
-
-  var isNodeJS = __w_pdfjs_require__(4);
-
-  var hasDOM = (typeof window === "undefined" ? "undefined" : _typeof(window)) === 'object' && (typeof document === "undefined" ? "undefined" : _typeof(document)) === 'object';
-
-  (function checkNodeBtoa() {
-    if (globalScope.btoa || !isNodeJS()) {
-      return;
-    }
-
-    globalScope.btoa = function (chars) {
-      return Buffer.from(chars, 'binary').toString('base64');
-    };
-  })();
-
-  (function checkNodeAtob() {
-    if (globalScope.atob || !isNodeJS()) {
-      return;
-    }
-
-    globalScope.atob = function (input) {
-      return Buffer.from(input, 'base64').toString('binary');
-    };
-  })();
-
-  (function checkChildNodeRemove() {
-    if (!hasDOM) {
-      return;
-    }
-
-    if (typeof Element.prototype.remove !== 'undefined') {
-      return;
-    }
-
-    Element.prototype.remove = function () {
-      if (this.parentNode) {
-        this.parentNode.removeChild(this);
-      }
-    };
-  })();
-
-  (function checkDOMTokenListAddRemove() {
-    if (!hasDOM || isNodeJS()) {
-      return;
-    }
-
-    var div = document.createElement('div');
-    div.classList.add('testOne', 'testTwo');
-
-    if (div.classList.contains('testOne') === true && div.classList.contains('testTwo') === true) {
-      return;
-    }
-
-    var OriginalDOMTokenListAdd = DOMTokenList.prototype.add;
-    var OriginalDOMTokenListRemove = DOMTokenList.prototype.remove;
-
-    DOMTokenList.prototype.add = function () {
-      for (var _len = arguments.length, tokens = new Array(_len), _key = 0; _key < _len; _key++) {
-        tokens[_key] = arguments[_key];
-      }
-
-      for (var _i = 0, _tokens = tokens; _i < _tokens.length; _i++) {
-        var token = _tokens[_i];
-        OriginalDOMTokenListAdd.call(this, token);
-      }
-    };
-
-    DOMTokenList.prototype.remove = function () {
-      for (var _len2 = arguments.length, tokens = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
-        tokens[_key2] = arguments[_key2];
-      }
-
-      for (var _i2 = 0, _tokens2 = tokens; _i2 < _tokens2.length; _i2++) {
-        var token = _tokens2[_i2];
-        OriginalDOMTokenListRemove.call(this, token);
-      }
-    };
-  })();
-
-  (function checkDOMTokenListToggle() {
-    if (!hasDOM || isNodeJS()) {
-      return;
-    }
-
-    var div = document.createElement('div');
-
-    if (div.classList.toggle('test', 0) === false) {
-      return;
-    }
-
-    DOMTokenList.prototype.toggle = function (token) {
-      var force = arguments.length > 1 ? !!arguments[1] : !this.contains(token);
-      return this[force ? 'add' : 'remove'](token), force;
-    };
-  })();
-
-  (function checkStringStartsWith() {
-    if (String.prototype.startsWith) {
-      return;
-    }
-
-    __w_pdfjs_require__(5);
-  })();
-
-  (function checkStringEndsWith() {
-    if (String.prototype.endsWith) {
-      return;
-    }
-
-    __w_pdfjs_require__(36);
-  })();
-
-  (function checkStringIncludes() {
-    if (String.prototype.includes) {
-      return;
-    }
-
-    __w_pdfjs_require__(38);
-  })();
-
-  (function checkArrayIncludes() {
-    if (Array.prototype.includes) {
-      return;
-    }
-
-    __w_pdfjs_require__(40);
-  })();
-
-  (function checkArrayFrom() {
-    if (Array.from) {
-      return;
-    }
-
-    __w_pdfjs_require__(47);
-  })();
-
-  (function checkObjectAssign() {
-    if (Object.assign) {
-      return;
-    }
-
-    __w_pdfjs_require__(70);
-  })();
-
-  (function checkMathLog2() {
-    if (Math.log2) {
-      return;
-    }
-
-    Math.log2 = __w_pdfjs_require__(75);
-  })();
-
-  (function checkNumberIsNaN() {
-    if (Number.isNaN) {
-      return;
-    }
-
-    Number.isNaN = __w_pdfjs_require__(77);
-  })();
-
-  (function checkNumberIsInteger() {
-    if (Number.isInteger) {
-      return;
-    }
-
-    Number.isInteger = __w_pdfjs_require__(79);
-  })();
-
-  (function checkPromise() {
-    if (globalScope.Promise && globalScope.Promise.prototype && globalScope.Promise.prototype["finally"]) {
-      return;
-    }
-
-    globalScope.Promise = __w_pdfjs_require__(82);
-  })();
-
-  (function checkWeakMap() {
-    if (globalScope.WeakMap) {
-      return;
-    }
-
-    globalScope.WeakMap = __w_pdfjs_require__(102);
-  })();
-
-  (function checkWeakSet() {
-    if (globalScope.WeakSet) {
-      return;
-    }
-
-    globalScope.WeakSet = __w_pdfjs_require__(119);
-  })();
-
-  (function checkStringCodePointAt() {
-    if (String.codePointAt) {
-      return;
-    }
-
-    String.codePointAt = __w_pdfjs_require__(123);
-  })();
-
-  (function checkStringFromCodePoint() {
-    if (String.fromCodePoint) {
-      return;
-    }
-
-    String.fromCodePoint = __w_pdfjs_require__(125);
-  })();
-
-  (function checkSymbol() {
-    if (globalScope.Symbol) {
-      return;
-    }
-
-    __w_pdfjs_require__(127);
-  })();
-
-  (function checkStringPadStart() {
-    if (String.prototype.padStart) {
-      return;
-    }
-
-    __w_pdfjs_require__(134);
-  })();
-
-  (function checkStringPadEnd() {
-    if (String.prototype.padEnd) {
-      return;
-    }
-
-    __w_pdfjs_require__(138);
-  })();
-
-  (function checkObjectValues() {
-    if (Object.values) {
-      return;
-    }
-
-    Object.values = __w_pdfjs_require__(140);
-  })();
-}
-
-/***/ }),
-/* 3 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-module.exports = typeof window !== 'undefined' && window.Math === Math ? window : typeof global !== 'undefined' && global.Math === Math ? global : typeof self !== 'undefined' && self.Math === Math ? self : {};
-
-/***/ }),
-/* 4 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-module.exports = function isNodeJS() {
-  return (typeof process === "undefined" ? "undefined" : _typeof(process)) === 'object' && process + '' === '[object process]' && !process.versions['nw'] && !process.versions['electron'];
-};
-
-/***/ }),
-/* 5 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(6);
-
-module.exports = __w_pdfjs_require__(9).String.startsWith;
-
-/***/ }),
-/* 6 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $export = __w_pdfjs_require__(7);
-
-var toLength = __w_pdfjs_require__(28);
-
-var context = __w_pdfjs_require__(30);
-
-var STARTS_WITH = 'startsWith';
-var $startsWith = ''[STARTS_WITH];
-$export($export.P + $export.F * __w_pdfjs_require__(35)(STARTS_WITH), 'String', {
-  startsWith: function startsWith(searchString) {
-    var that = context(this, searchString, STARTS_WITH);
-    var index = toLength(Math.min(arguments.length > 1 ? arguments[1] : undefined, that.length));
-    var search = String(searchString);
-    return $startsWith ? $startsWith.call(that, search, index) : that.slice(index, index + search.length) === search;
-  }
-});
-
-/***/ }),
-/* 7 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var global = __w_pdfjs_require__(8);
-
-var core = __w_pdfjs_require__(9);
-
-var hide = __w_pdfjs_require__(10);
-
-var redefine = __w_pdfjs_require__(20);
-
-var ctx = __w_pdfjs_require__(26);
-
-var PROTOTYPE = 'prototype';
-
-var $export = function $export(type, name, source) {
-  var IS_FORCED = type & $export.F;
-  var IS_GLOBAL = type & $export.G;
-  var IS_STATIC = type & $export.S;
-  var IS_PROTO = type & $export.P;
-  var IS_BIND = type & $export.B;
-  var target = IS_GLOBAL ? global : IS_STATIC ? global[name] || (global[name] = {}) : (global[name] || {})[PROTOTYPE];
-  var exports = IS_GLOBAL ? core : core[name] || (core[name] = {});
-  var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});
-  var key, own, out, exp;
-  if (IS_GLOBAL) source = name;
-
-  for (key in source) {
-    own = !IS_FORCED && target && target[key] !== undefined;
-    out = (own ? target : source)[key];
-    exp = IS_BIND && own ? ctx(out, global) : IS_PROTO && typeof out == 'function' ? ctx(Function.call, out) : out;
-    if (target) redefine(target, key, out, type & $export.U);
-    if (exports[key] != out) hide(exports, key, exp);
-    if (IS_PROTO && expProto[key] != out) expProto[key] = out;
-  }
-};
-
-global.core = core;
-$export.F = 1;
-$export.G = 2;
-$export.S = 4;
-$export.P = 8;
-$export.B = 16;
-$export.W = 32;
-$export.U = 64;
-$export.R = 128;
-module.exports = $export;
-
-/***/ }),
-/* 8 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var global = module.exports = typeof window != 'undefined' && window.Math == Math ? window : typeof self != 'undefined' && self.Math == Math ? self : Function('return this')();
-if (typeof __g == 'number') __g = global;
-
-/***/ }),
-/* 9 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var core = module.exports = {
-  version: '2.6.9'
-};
-if (typeof __e == 'number') __e = core;
-
-/***/ }),
-/* 10 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var dP = __w_pdfjs_require__(11);
-
-var createDesc = __w_pdfjs_require__(19);
-
-module.exports = __w_pdfjs_require__(15) ? function (object, key, value) {
-  return dP.f(object, key, createDesc(1, value));
-} : function (object, key, value) {
-  object[key] = value;
-  return object;
-};
-
-/***/ }),
-/* 11 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var anObject = __w_pdfjs_require__(12);
-
-var IE8_DOM_DEFINE = __w_pdfjs_require__(14);
-
-var toPrimitive = __w_pdfjs_require__(18);
-
-var dP = Object.defineProperty;
-exports.f = __w_pdfjs_require__(15) ? Object.defineProperty : function defineProperty(O, P, Attributes) {
-  anObject(O);
-  P = toPrimitive(P, true);
-  anObject(Attributes);
-  if (IE8_DOM_DEFINE) try {
-    return dP(O, P, Attributes);
-  } catch (e) {}
-  if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');
-  if ('value' in Attributes) O[P] = Attributes.value;
-  return O;
-};
-
-/***/ }),
-/* 12 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var isObject = __w_pdfjs_require__(13);
-
-module.exports = function (it) {
-  if (!isObject(it)) throw TypeError(it + ' is not an object!');
-  return it;
-};
-
-/***/ }),
-/* 13 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-module.exports = function (it) {
-  return _typeof(it) === 'object' ? it !== null : typeof it === 'function';
-};
-
-/***/ }),
-/* 14 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-module.exports = !__w_pdfjs_require__(15) && !__w_pdfjs_require__(16)(function () {
-  return Object.defineProperty(__w_pdfjs_require__(17)('div'), 'a', {
-    get: function get() {
-      return 7;
-    }
-  }).a != 7;
-});
-
-/***/ }),
-/* 15 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-module.exports = !__w_pdfjs_require__(16)(function () {
-  return Object.defineProperty({}, 'a', {
-    get: function get() {
-      return 7;
-    }
-  }).a != 7;
-});
-
-/***/ }),
-/* 16 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-module.exports = function (exec) {
-  try {
-    return !!exec();
-  } catch (e) {
-    return true;
-  }
-};
-
-/***/ }),
-/* 17 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var isObject = __w_pdfjs_require__(13);
-
-var document = __w_pdfjs_require__(8).document;
-
-var is = isObject(document) && isObject(document.createElement);
-
-module.exports = function (it) {
-  return is ? document.createElement(it) : {};
-};
-
-/***/ }),
-/* 18 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var isObject = __w_pdfjs_require__(13);
-
-module.exports = function (it, S) {
-  if (!isObject(it)) return it;
-  var fn, val;
-  if (S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
-  if (typeof (fn = it.valueOf) == 'function' && !isObject(val = fn.call(it))) return val;
-  if (!S && typeof (fn = it.toString) == 'function' && !isObject(val = fn.call(it))) return val;
-  throw TypeError("Can't convert object to primitive value");
-};
-
-/***/ }),
-/* 19 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-module.exports = function (bitmap, value) {
-  return {
-    enumerable: !(bitmap & 1),
-    configurable: !(bitmap & 2),
-    writable: !(bitmap & 4),
-    value: value
-  };
-};
-
-/***/ }),
-/* 20 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var global = __w_pdfjs_require__(8);
-
-var hide = __w_pdfjs_require__(10);
-
-var has = __w_pdfjs_require__(21);
-
-var SRC = __w_pdfjs_require__(22)('src');
-
-var $toString = __w_pdfjs_require__(23);
-
-var TO_STRING = 'toString';
-var TPL = ('' + $toString).split(TO_STRING);
-
-__w_pdfjs_require__(9).inspectSource = function (it) {
-  return $toString.call(it);
-};
-
-(module.exports = function (O, key, val, safe) {
-  var isFunction = typeof val == 'function';
-  if (isFunction) has(val, 'name') || hide(val, 'name', key);
-  if (O[key] === val) return;
-  if (isFunction) has(val, SRC) || hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));
-
-  if (O === global) {
-    O[key] = val;
-  } else if (!safe) {
-    delete O[key];
-    hide(O, key, val);
-  } else if (O[key]) {
-    O[key] = val;
-  } else {
-    hide(O, key, val);
-  }
-})(Function.prototype, TO_STRING, function toString() {
-  return typeof this == 'function' && this[SRC] || $toString.call(this);
-});
-
-/***/ }),
-/* 21 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var hasOwnProperty = {}.hasOwnProperty;
-
-module.exports = function (it, key) {
-  return hasOwnProperty.call(it, key);
-};
-
-/***/ }),
-/* 22 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var id = 0;
-var px = Math.random();
-
-module.exports = function (key) {
-  return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));
-};
-
-/***/ }),
-/* 23 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-module.exports = __w_pdfjs_require__(24)('native-function-to-string', Function.toString);
-
-/***/ }),
-/* 24 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var core = __w_pdfjs_require__(9);
-
-var global = __w_pdfjs_require__(8);
-
-var SHARED = '__core-js_shared__';
-var store = global[SHARED] || (global[SHARED] = {});
-(module.exports = function (key, value) {
-  return store[key] || (store[key] = value !== undefined ? value : {});
-})('versions', []).push({
-  version: core.version,
-  mode: __w_pdfjs_require__(25) ? 'pure' : 'global',
-  copyright: '© 2019 Denis Pushkarev (zloirock.ru)'
-});
-
-/***/ }),
-/* 25 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-module.exports = false;
-
-/***/ }),
-/* 26 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var aFunction = __w_pdfjs_require__(27);
-
-module.exports = function (fn, that, length) {
-  aFunction(fn);
-  if (that === undefined) return fn;
-
-  switch (length) {
-    case 1:
-      return function (a) {
-        return fn.call(that, a);
-      };
-
-    case 2:
-      return function (a, b) {
-        return fn.call(that, a, b);
-      };
-
-    case 3:
-      return function (a, b, c) {
-        return fn.call(that, a, b, c);
-      };
-  }
-
-  return function () {
-    return fn.apply(that, arguments);
-  };
-};
-
-/***/ }),
-/* 27 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-module.exports = function (it) {
-  if (typeof it != 'function') throw TypeError(it + ' is not a function!');
-  return it;
-};
-
-/***/ }),
-/* 28 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var toInteger = __w_pdfjs_require__(29);
-
-var min = Math.min;
-
-module.exports = function (it) {
-  return it > 0 ? min(toInteger(it), 0x1fffffffffffff) : 0;
-};
-
-/***/ }),
-/* 29 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var ceil = Math.ceil;
-var floor = Math.floor;
-
-module.exports = function (it) {
-  return isNaN(it = +it) ? 0 : (it > 0 ? floor : ceil)(it);
-};
-
-/***/ }),
-/* 30 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var isRegExp = __w_pdfjs_require__(31);
-
-var defined = __w_pdfjs_require__(34);
-
-module.exports = function (that, searchString, NAME) {
-  if (isRegExp(searchString)) throw TypeError('String#' + NAME + " doesn't accept regex!");
-  return String(defined(that));
-};
-
-/***/ }),
-/* 31 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var isObject = __w_pdfjs_require__(13);
-
-var cof = __w_pdfjs_require__(32);
-
-var MATCH = __w_pdfjs_require__(33)('match');
-
-module.exports = function (it) {
-  var isRegExp;
-  return isObject(it) && ((isRegExp = it[MATCH]) !== undefined ? !!isRegExp : cof(it) == 'RegExp');
-};
-
-/***/ }),
-/* 32 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var toString = {}.toString;
-
-module.exports = function (it) {
-  return toString.call(it).slice(8, -1);
-};
-
-/***/ }),
-/* 33 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var store = __w_pdfjs_require__(24)('wks');
-
-var uid = __w_pdfjs_require__(22);
-
-var _Symbol = __w_pdfjs_require__(8).Symbol;
-
-var USE_SYMBOL = typeof _Symbol == 'function';
-
-var $exports = module.exports = function (name) {
-  return store[name] || (store[name] = USE_SYMBOL && _Symbol[name] || (USE_SYMBOL ? _Symbol : uid)('Symbol.' + name));
-};
-
-$exports.store = store;
-
-/***/ }),
-/* 34 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-module.exports = function (it) {
-  if (it == undefined) throw TypeError("Can't call method on  " + it);
-  return it;
-};
-
-/***/ }),
-/* 35 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var MATCH = __w_pdfjs_require__(33)('match');
-
-module.exports = function (KEY) {
-  var re = /./;
-
-  try {
-    '/./'[KEY](re);
-  } catch (e) {
-    try {
-      re[MATCH] = false;
-      return !'/./'[KEY](re);
-    } catch (f) {}
-  }
-
-  return true;
-};
-
-/***/ }),
-/* 36 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(37);
-
-module.exports = __w_pdfjs_require__(9).String.endsWith;
-
-/***/ }),
-/* 37 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $export = __w_pdfjs_require__(7);
-
-var toLength = __w_pdfjs_require__(28);
-
-var context = __w_pdfjs_require__(30);
-
-var ENDS_WITH = 'endsWith';
-var $endsWith = ''[ENDS_WITH];
-$export($export.P + $export.F * __w_pdfjs_require__(35)(ENDS_WITH), 'String', {
-  endsWith: function endsWith(searchString) {
-    var that = context(this, searchString, ENDS_WITH);
-    var endPosition = arguments.length > 1 ? arguments[1] : undefined;
-    var len = toLength(that.length);
-    var end = endPosition === undefined ? len : Math.min(toLength(endPosition), len);
-    var search = String(searchString);
-    return $endsWith ? $endsWith.call(that, search, end) : that.slice(end - search.length, end) === search;
-  }
-});
-
-/***/ }),
-/* 38 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(39);
-
-module.exports = __w_pdfjs_require__(9).String.includes;
-
-/***/ }),
-/* 39 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $export = __w_pdfjs_require__(7);
-
-var context = __w_pdfjs_require__(30);
-
-var INCLUDES = 'includes';
-$export($export.P + $export.F * __w_pdfjs_require__(35)(INCLUDES), 'String', {
-  includes: function includes(searchString) {
-    return !!~context(this, searchString, INCLUDES).indexOf(searchString, arguments.length > 1 ? arguments[1] : undefined);
-  }
-});
-
-/***/ }),
-/* 40 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(41);
-
-module.exports = __w_pdfjs_require__(9).Array.includes;
-
-/***/ }),
-/* 41 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $export = __w_pdfjs_require__(7);
-
-var $includes = __w_pdfjs_require__(42)(true);
-
-$export($export.P, 'Array', {
-  includes: function includes(el) {
-    return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
-  }
-});
-
-__w_pdfjs_require__(46)('includes');
-
-/***/ }),
-/* 42 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var toIObject = __w_pdfjs_require__(43);
-
-var toLength = __w_pdfjs_require__(28);
-
-var toAbsoluteIndex = __w_pdfjs_require__(45);
-
-module.exports = function (IS_INCLUDES) {
-  return function ($this, el, fromIndex) {
-    var O = toIObject($this);
-    var length = toLength(O.length);
-    var index = toAbsoluteIndex(fromIndex, length);
-    var value;
-    if (IS_INCLUDES && el != el) while (length > index) {
-      value = O[index++];
-      if (value != value) return true;
-    } else for (; length > index; index++) {
-      if (IS_INCLUDES || index in O) {
-        if (O[index] === el) return IS_INCLUDES || index || 0;
-      }
-    }
-    return !IS_INCLUDES && -1;
-  };
-};
-
-/***/ }),
-/* 43 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var IObject = __w_pdfjs_require__(44);
-
-var defined = __w_pdfjs_require__(34);
-
-module.exports = function (it) {
-  return IObject(defined(it));
-};
-
-/***/ }),
-/* 44 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var cof = __w_pdfjs_require__(32);
-
-module.exports = Object('z').propertyIsEnumerable(0) ? Object : function (it) {
-  return cof(it) == 'String' ? it.split('') : Object(it);
-};
-
-/***/ }),
-/* 45 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var toInteger = __w_pdfjs_require__(29);
-
-var max = Math.max;
-var min = Math.min;
-
-module.exports = function (index, length) {
-  index = toInteger(index);
-  return index < 0 ? max(index + length, 0) : min(index, length);
-};
-
-/***/ }),
-/* 46 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var UNSCOPABLES = __w_pdfjs_require__(33)('unscopables');
-
-var ArrayProto = Array.prototype;
-if (ArrayProto[UNSCOPABLES] == undefined) __w_pdfjs_require__(10)(ArrayProto, UNSCOPABLES, {});
-
-module.exports = function (key) {
-  ArrayProto[UNSCOPABLES][key] = true;
-};
-
-/***/ }),
-/* 47 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(48);
-
-__w_pdfjs_require__(63);
-
-module.exports = __w_pdfjs_require__(9).Array.from;
-
-/***/ }),
-/* 48 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $at = __w_pdfjs_require__(49)(true);
-
-__w_pdfjs_require__(50)(String, 'String', function (iterated) {
-  this._t = String(iterated);
-  this._i = 0;
-}, function () {
-  var O = this._t;
-  var index = this._i;
-  var point;
-  if (index >= O.length) return {
-    value: undefined,
-    done: true
-  };
-  point = $at(O, index);
-  this._i += point.length;
-  return {
-    value: point,
-    done: false
-  };
-});
-
-/***/ }),
-/* 49 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var toInteger = __w_pdfjs_require__(29);
-
-var defined = __w_pdfjs_require__(34);
-
-module.exports = function (TO_STRING) {
-  return function (that, pos) {
-    var s = String(defined(that));
-    var i = toInteger(pos);
-    var l = s.length;
-    var a, b;
-    if (i < 0 || i >= l) return TO_STRING ? '' : undefined;
-    a = s.charCodeAt(i);
-    return a < 0xd800 || a > 0xdbff || i + 1 === l || (b = s.charCodeAt(i + 1)) < 0xdc00 || b > 0xdfff ? TO_STRING ? s.charAt(i) : a : TO_STRING ? s.slice(i, i + 2) : (a - 0xd800 << 10) + (b - 0xdc00) + 0x10000;
-  };
-};
-
-/***/ }),
-/* 50 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var LIBRARY = __w_pdfjs_require__(25);
-
-var $export = __w_pdfjs_require__(7);
-
-var redefine = __w_pdfjs_require__(20);
-
-var hide = __w_pdfjs_require__(10);
-
-var Iterators = __w_pdfjs_require__(51);
-
-var $iterCreate = __w_pdfjs_require__(52);
-
-var setToStringTag = __w_pdfjs_require__(60);
-
-var getPrototypeOf = __w_pdfjs_require__(61);
-
-var ITERATOR = __w_pdfjs_require__(33)('iterator');
-
-var BUGGY = !([].keys && 'next' in [].keys());
-var FF_ITERATOR = '@@iterator';
-var KEYS = 'keys';
-var VALUES = 'values';
-
-var returnThis = function returnThis() {
-  return this;
-};
-
-module.exports = function (Base, NAME, Constructor, next, DEFAULT, IS_SET, FORCED) {
-  $iterCreate(Constructor, NAME, next);
-
-  var getMethod = function getMethod(kind) {
-    if (!BUGGY && kind in proto) return proto[kind];
-
-    switch (kind) {
-      case KEYS:
-        return function keys() {
-          return new Constructor(this, kind);
-        };
-
-      case VALUES:
-        return function values() {
-          return new Constructor(this, kind);
-        };
-    }
-
-    return function entries() {
-      return new Constructor(this, kind);
-    };
-  };
-
-  var TAG = NAME + ' Iterator';
-  var DEF_VALUES = DEFAULT == VALUES;
-  var VALUES_BUG = false;
-  var proto = Base.prototype;
-  var $native = proto[ITERATOR] || proto[FF_ITERATOR] || DEFAULT && proto[DEFAULT];
-  var $default = $native || getMethod(DEFAULT);
-  var $entries = DEFAULT ? !DEF_VALUES ? $default : getMethod('entries') : undefined;
-  var $anyNative = NAME == 'Array' ? proto.entries || $native : $native;
-  var methods, key, IteratorPrototype;
-
-  if ($anyNative) {
-    IteratorPrototype = getPrototypeOf($anyNative.call(new Base()));
-
-    if (IteratorPrototype !== Object.prototype && IteratorPrototype.next) {
-      setToStringTag(IteratorPrototype, TAG, true);
-      if (!LIBRARY && typeof IteratorPrototype[ITERATOR] != 'function') hide(IteratorPrototype, ITERATOR, returnThis);
-    }
-  }
-
-  if (DEF_VALUES && $native && $native.name !== VALUES) {
-    VALUES_BUG = true;
-
-    $default = function values() {
-      return $native.call(this);
-    };
-  }
-
-  if ((!LIBRARY || FORCED) && (BUGGY || VALUES_BUG || !proto[ITERATOR])) {
-    hide(proto, ITERATOR, $default);
-  }
-
-  Iterators[NAME] = $default;
-  Iterators[TAG] = returnThis;
-
-  if (DEFAULT) {
-    methods = {
-      values: DEF_VALUES ? $default : getMethod(VALUES),
-      keys: IS_SET ? $default : getMethod(KEYS),
-      entries: $entries
-    };
-    if (FORCED) for (key in methods) {
-      if (!(key in proto)) redefine(proto, key, methods[key]);
-    } else $export($export.P + $export.F * (BUGGY || VALUES_BUG), NAME, methods);
-  }
-
-  return methods;
-};
-
-/***/ }),
-/* 51 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-module.exports = {};
-
-/***/ }),
-/* 52 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var create = __w_pdfjs_require__(53);
-
-var descriptor = __w_pdfjs_require__(19);
-
-var setToStringTag = __w_pdfjs_require__(60);
-
-var IteratorPrototype = {};
-
-__w_pdfjs_require__(10)(IteratorPrototype, __w_pdfjs_require__(33)('iterator'), function () {
-  return this;
-});
-
-module.exports = function (Constructor, NAME, next) {
-  Constructor.prototype = create(IteratorPrototype, {
-    next: descriptor(1, next)
-  });
-  setToStringTag(Constructor, NAME + ' Iterator');
-};
-
-/***/ }),
-/* 53 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var anObject = __w_pdfjs_require__(12);
-
-var dPs = __w_pdfjs_require__(54);
-
-var enumBugKeys = __w_pdfjs_require__(58);
-
-var IE_PROTO = __w_pdfjs_require__(57)('IE_PROTO');
-
-var Empty = function Empty() {};
-
-var PROTOTYPE = 'prototype';
-
-var _createDict = function createDict() {
-  var iframe = __w_pdfjs_require__(17)('iframe');
-
-  var i = enumBugKeys.length;
-  var lt = '<';
-  var gt = '>';
-  var iframeDocument;
-  iframe.style.display = 'none';
-
-  __w_pdfjs_require__(59).appendChild(iframe);
-
-  iframe.src = 'javascript:';
-  iframeDocument = iframe.contentWindow.document;
-  iframeDocument.open();
-  iframeDocument.write(lt + 'script' + gt + 'document.F=Object' + lt + '/script' + gt);
-  iframeDocument.close();
-  _createDict = iframeDocument.F;
-
-  while (i--) {
-    delete _createDict[PROTOTYPE][enumBugKeys[i]];
-  }
-
-  return _createDict();
-};
-
-module.exports = Object.create || function create(O, Properties) {
-  var result;
-
-  if (O !== null) {
-    Empty[PROTOTYPE] = anObject(O);
-    result = new Empty();
-    Empty[PROTOTYPE] = null;
-    result[IE_PROTO] = O;
-  } else result = _createDict();
-
-  return Properties === undefined ? result : dPs(result, Properties);
-};
-
-/***/ }),
-/* 54 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var dP = __w_pdfjs_require__(11);
-
-var anObject = __w_pdfjs_require__(12);
-
-var getKeys = __w_pdfjs_require__(55);
-
-module.exports = __w_pdfjs_require__(15) ? Object.defineProperties : function defineProperties(O, Properties) {
-  anObject(O);
-  var keys = getKeys(Properties);
-  var length = keys.length;
-  var i = 0;
-  var P;
-
-  while (length > i) {
-    dP.f(O, P = keys[i++], Properties[P]);
-  }
-
-  return O;
-};
-
-/***/ }),
-/* 55 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $keys = __w_pdfjs_require__(56);
-
-var enumBugKeys = __w_pdfjs_require__(58);
-
-module.exports = Object.keys || function keys(O) {
-  return $keys(O, enumBugKeys);
-};
-
-/***/ }),
-/* 56 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var has = __w_pdfjs_require__(21);
-
-var toIObject = __w_pdfjs_require__(43);
-
-var arrayIndexOf = __w_pdfjs_require__(42)(false);
-
-var IE_PROTO = __w_pdfjs_require__(57)('IE_PROTO');
-
-module.exports = function (object, names) {
-  var O = toIObject(object);
-  var i = 0;
-  var result = [];
-  var key;
-
-  for (key in O) {
-    if (key != IE_PROTO) has(O, key) && result.push(key);
-  }
-
-  while (names.length > i) {
-    if (has(O, key = names[i++])) {
-      ~arrayIndexOf(result, key) || result.push(key);
-    }
-  }
-
-  return result;
-};
-
-/***/ }),
-/* 57 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var shared = __w_pdfjs_require__(24)('keys');
-
-var uid = __w_pdfjs_require__(22);
-
-module.exports = function (key) {
-  return shared[key] || (shared[key] = uid(key));
-};
-
-/***/ }),
-/* 58 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-module.exports = 'constructor,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString,toString,valueOf'.split(',');
-
-/***/ }),
-/* 59 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var document = __w_pdfjs_require__(8).document;
-
-module.exports = document && document.documentElement;
-
-/***/ }),
-/* 60 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var def = __w_pdfjs_require__(11).f;
-
-var has = __w_pdfjs_require__(21);
-
-var TAG = __w_pdfjs_require__(33)('toStringTag');
-
-module.exports = function (it, tag, stat) {
-  if (it && !has(it = stat ? it : it.prototype, TAG)) def(it, TAG, {
-    configurable: true,
-    value: tag
-  });
-};
-
-/***/ }),
-/* 61 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var has = __w_pdfjs_require__(21);
-
-var toObject = __w_pdfjs_require__(62);
-
-var IE_PROTO = __w_pdfjs_require__(57)('IE_PROTO');
-
-var ObjectProto = Object.prototype;
-
-module.exports = Object.getPrototypeOf || function (O) {
-  O = toObject(O);
-  if (has(O, IE_PROTO)) return O[IE_PROTO];
-
-  if (typeof O.constructor == 'function' && O instanceof O.constructor) {
-    return O.constructor.prototype;
-  }
-
-  return O instanceof Object ? ObjectProto : null;
-};
-
-/***/ }),
-/* 62 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var defined = __w_pdfjs_require__(34);
-
-module.exports = function (it) {
-  return Object(defined(it));
-};
-
-/***/ }),
-/* 63 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var ctx = __w_pdfjs_require__(26);
-
-var $export = __w_pdfjs_require__(7);
-
-var toObject = __w_pdfjs_require__(62);
-
-var call = __w_pdfjs_require__(64);
-
-var isArrayIter = __w_pdfjs_require__(65);
-
-var toLength = __w_pdfjs_require__(28);
-
-var createProperty = __w_pdfjs_require__(66);
-
-var getIterFn = __w_pdfjs_require__(67);
-
-$export($export.S + $export.F * !__w_pdfjs_require__(69)(function (iter) {
-  Array.from(iter);
-}), 'Array', {
-  from: function from(arrayLike) {
-    var O = toObject(arrayLike);
-    var C = typeof this == 'function' ? this : Array;
-    var aLen = arguments.length;
-    var mapfn = aLen > 1 ? arguments[1] : undefined;
-    var mapping = mapfn !== undefined;
-    var index = 0;
-    var iterFn = getIterFn(O);
-    var length, result, step, iterator;
-    if (mapping) mapfn = ctx(mapfn, aLen > 2 ? arguments[2] : undefined, 2);
-
-    if (iterFn != undefined && !(C == Array && isArrayIter(iterFn))) {
-      for (iterator = iterFn.call(O), result = new C(); !(step = iterator.next()).done; index++) {
-        createProperty(result, index, mapping ? call(iterator, mapfn, [step.value, index], true) : step.value);
-      }
-    } else {
-      length = toLength(O.length);
-
-      for (result = new C(length); length > index; index++) {
-        createProperty(result, index, mapping ? mapfn(O[index], index) : O[index]);
-      }
-    }
-
-    result.length = index;
-    return result;
-  }
-});
-
-/***/ }),
-/* 64 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var anObject = __w_pdfjs_require__(12);
-
-module.exports = function (iterator, fn, value, entries) {
-  try {
-    return entries ? fn(anObject(value)[0], value[1]) : fn(value);
-  } catch (e) {
-    var ret = iterator['return'];
-    if (ret !== undefined) anObject(ret.call(iterator));
-    throw e;
-  }
-};
-
-/***/ }),
-/* 65 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var Iterators = __w_pdfjs_require__(51);
-
-var ITERATOR = __w_pdfjs_require__(33)('iterator');
-
-var ArrayProto = Array.prototype;
-
-module.exports = function (it) {
-  return it !== undefined && (Iterators.Array === it || ArrayProto[ITERATOR] === it);
-};
-
-/***/ }),
-/* 66 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $defineProperty = __w_pdfjs_require__(11);
-
-var createDesc = __w_pdfjs_require__(19);
-
-module.exports = function (object, index, value) {
-  if (index in object) $defineProperty.f(object, index, createDesc(0, value));else object[index] = value;
-};
-
-/***/ }),
-/* 67 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var classof = __w_pdfjs_require__(68);
-
-var ITERATOR = __w_pdfjs_require__(33)('iterator');
-
-var Iterators = __w_pdfjs_require__(51);
-
-module.exports = __w_pdfjs_require__(9).getIteratorMethod = function (it) {
-  if (it != undefined) return it[ITERATOR] || it['@@iterator'] || Iterators[classof(it)];
-};
-
-/***/ }),
-/* 68 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var cof = __w_pdfjs_require__(32);
-
-var TAG = __w_pdfjs_require__(33)('toStringTag');
-
-var ARG = cof(function () {
-  return arguments;
-}()) == 'Arguments';
-
-var tryGet = function tryGet(it, key) {
-  try {
-    return it[key];
-  } catch (e) {}
-};
-
-module.exports = function (it) {
-  var O, T, B;
-  return it === undefined ? 'Undefined' : it === null ? 'Null' : typeof (T = tryGet(O = Object(it), TAG)) == 'string' ? T : ARG ? cof(O) : (B = cof(O)) == 'Object' && typeof O.callee == 'function' ? 'Arguments' : B;
-};
-
-/***/ }),
-/* 69 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var ITERATOR = __w_pdfjs_require__(33)('iterator');
-
-var SAFE_CLOSING = false;
-
-try {
-  var riter = [7][ITERATOR]();
-
-  riter['return'] = function () {
-    SAFE_CLOSING = true;
-  };
-
-  Array.from(riter, function () {
-    throw 2;
-  });
-} catch (e) {}
-
-module.exports = function (exec, skipClosing) {
-  if (!skipClosing && !SAFE_CLOSING) return false;
-  var safe = false;
-
-  try {
-    var arr = [7];
-    var iter = arr[ITERATOR]();
-
-    iter.next = function () {
-      return {
-        done: safe = true
-      };
-    };
-
-    arr[ITERATOR] = function () {
-      return iter;
-    };
-
-    exec(arr);
-  } catch (e) {}
-
-  return safe;
-};
-
-/***/ }),
-/* 70 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(71);
-
-module.exports = __w_pdfjs_require__(9).Object.assign;
-
-/***/ }),
-/* 71 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $export = __w_pdfjs_require__(7);
-
-$export($export.S + $export.F, 'Object', {
-  assign: __w_pdfjs_require__(72)
-});
-
-/***/ }),
-/* 72 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var DESCRIPTORS = __w_pdfjs_require__(15);
-
-var getKeys = __w_pdfjs_require__(55);
-
-var gOPS = __w_pdfjs_require__(73);
-
-var pIE = __w_pdfjs_require__(74);
-
-var toObject = __w_pdfjs_require__(62);
-
-var IObject = __w_pdfjs_require__(44);
-
-var $assign = Object.assign;
-module.exports = !$assign || __w_pdfjs_require__(16)(function () {
-  var A = {};
-  var B = {};
-  var S = Symbol();
-  var K = 'abcdefghijklmnopqrst';
-  A[S] = 7;
-  K.split('').forEach(function (k) {
-    B[k] = k;
-  });
-  return $assign({}, A)[S] != 7 || Object.keys($assign({}, B)).join('') != K;
-}) ? function assign(target, source) {
-  var T = toObject(target);
-  var aLen = arguments.length;
-  var index = 1;
-  var getSymbols = gOPS.f;
-  var isEnum = pIE.f;
-
-  while (aLen > index) {
-    var S = IObject(arguments[index++]);
-    var keys = getSymbols ? getKeys(S).concat(getSymbols(S)) : getKeys(S);
-    var length = keys.length;
-    var j = 0;
-    var key;
-
-    while (length > j) {
-      key = keys[j++];
-      if (!DESCRIPTORS || isEnum.call(S, key)) T[key] = S[key];
-    }
-  }
-
-  return T;
-} : $assign;
-
-/***/ }),
-/* 73 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-exports.f = Object.getOwnPropertySymbols;
-
-/***/ }),
-/* 74 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-exports.f = {}.propertyIsEnumerable;
-
-/***/ }),
-/* 75 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(76);
-
-module.exports = __w_pdfjs_require__(9).Math.log2;
-
-/***/ }),
-/* 76 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $export = __w_pdfjs_require__(7);
-
-$export($export.S, 'Math', {
-  log2: function log2(x) {
-    return Math.log(x) / Math.LN2;
-  }
-});
-
-/***/ }),
-/* 77 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(78);
-
-module.exports = __w_pdfjs_require__(9).Number.isNaN;
-
-/***/ }),
-/* 78 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $export = __w_pdfjs_require__(7);
-
-$export($export.S, 'Number', {
-  isNaN: function isNaN(number) {
-    return number != number;
-  }
-});
-
-/***/ }),
-/* 79 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(80);
-
-module.exports = __w_pdfjs_require__(9).Number.isInteger;
-
-/***/ }),
-/* 80 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $export = __w_pdfjs_require__(7);
-
-$export($export.S, 'Number', {
-  isInteger: __w_pdfjs_require__(81)
-});
-
-/***/ }),
-/* 81 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var isObject = __w_pdfjs_require__(13);
-
-var floor = Math.floor;
-
-module.exports = function isInteger(it) {
-  return !isObject(it) && isFinite(it) && floor(it) === it;
-};
-
-/***/ }),
-/* 82 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(83);
-
-__w_pdfjs_require__(48);
-
-__w_pdfjs_require__(84);
-
-__w_pdfjs_require__(87);
-
-__w_pdfjs_require__(100);
-
-__w_pdfjs_require__(101);
-
-module.exports = __w_pdfjs_require__(9).Promise;
-
-/***/ }),
-/* 83 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var classof = __w_pdfjs_require__(68);
-
-var test = {};
-test[__w_pdfjs_require__(33)('toStringTag')] = 'z';
-
-if (test + '' != '[object z]') {
-  __w_pdfjs_require__(20)(Object.prototype, 'toString', function toString() {
-    return '[object ' + classof(this) + ']';
-  }, true);
-}
-
-/***/ }),
-/* 84 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $iterators = __w_pdfjs_require__(85);
-
-var getKeys = __w_pdfjs_require__(55);
-
-var redefine = __w_pdfjs_require__(20);
-
-var global = __w_pdfjs_require__(8);
-
-var hide = __w_pdfjs_require__(10);
-
-var Iterators = __w_pdfjs_require__(51);
-
-var wks = __w_pdfjs_require__(33);
-
-var ITERATOR = wks('iterator');
-var TO_STRING_TAG = wks('toStringTag');
-var ArrayValues = Iterators.Array;
-var DOMIterables = {
-  CSSRuleList: true,
-  CSSStyleDeclaration: false,
-  CSSValueList: false,
-  ClientRectList: false,
-  DOMRectList: false,
-  DOMStringList: false,
-  DOMTokenList: true,
-  DataTransferItemList: false,
-  FileList: false,
-  HTMLAllCollection: false,
-  HTMLCollection: false,
-  HTMLFormElement: false,
-  HTMLSelectElement: false,
-  MediaList: true,
-  MimeTypeArray: false,
-  NamedNodeMap: false,
-  NodeList: true,
-  PaintRequestList: false,
-  Plugin: false,
-  PluginArray: false,
-  SVGLengthList: false,
-  SVGNumberList: false,
-  SVGPathSegList: false,
-  SVGPointList: false,
-  SVGStringList: false,
-  SVGTransformList: false,
-  SourceBufferList: false,
-  StyleSheetList: true,
-  TextTrackCueList: false,
-  TextTrackList: false,
-  TouchList: false
-};
-
-for (var collections = getKeys(DOMIterables), i = 0; i < collections.length; i++) {
-  var NAME = collections[i];
-  var explicit = DOMIterables[NAME];
-  var Collection = global[NAME];
-  var proto = Collection && Collection.prototype;
-  var key;
-
-  if (proto) {
-    if (!proto[ITERATOR]) hide(proto, ITERATOR, ArrayValues);
-    if (!proto[TO_STRING_TAG]) hide(proto, TO_STRING_TAG, NAME);
-    Iterators[NAME] = ArrayValues;
-    if (explicit) for (key in $iterators) {
-      if (!proto[key]) redefine(proto, key, $iterators[key], true);
-    }
-  }
-}
-
-/***/ }),
-/* 85 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var addToUnscopables = __w_pdfjs_require__(46);
-
-var step = __w_pdfjs_require__(86);
-
-var Iterators = __w_pdfjs_require__(51);
-
-var toIObject = __w_pdfjs_require__(43);
-
-module.exports = __w_pdfjs_require__(50)(Array, 'Array', function (iterated, kind) {
-  this._t = toIObject(iterated);
-  this._i = 0;
-  this._k = kind;
-}, function () {
-  var O = this._t;
-  var kind = this._k;
-  var index = this._i++;
-
-  if (!O || index >= O.length) {
-    this._t = undefined;
-    return step(1);
-  }
-
-  if (kind == 'keys') return step(0, index);
-  if (kind == 'values') return step(0, O[index]);
-  return step(0, [index, O[index]]);
-}, 'values');
-Iterators.Arguments = Iterators.Array;
-addToUnscopables('keys');
-addToUnscopables('values');
-addToUnscopables('entries');
-
-/***/ }),
-/* 86 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-module.exports = function (done, value) {
-  return {
-    value: value,
-    done: !!done
-  };
-};
-
-/***/ }),
-/* 87 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var LIBRARY = __w_pdfjs_require__(25);
-
-var global = __w_pdfjs_require__(8);
-
-var ctx = __w_pdfjs_require__(26);
-
-var classof = __w_pdfjs_require__(68);
-
-var $export = __w_pdfjs_require__(7);
-
-var isObject = __w_pdfjs_require__(13);
-
-var aFunction = __w_pdfjs_require__(27);
-
-var anInstance = __w_pdfjs_require__(88);
-
-var forOf = __w_pdfjs_require__(89);
-
-var speciesConstructor = __w_pdfjs_require__(90);
-
-var task = __w_pdfjs_require__(91).set;
-
-var microtask = __w_pdfjs_require__(93)();
-
-var newPromiseCapabilityModule = __w_pdfjs_require__(94);
-
-var perform = __w_pdfjs_require__(95);
-
-var userAgent = __w_pdfjs_require__(96);
-
-var promiseResolve = __w_pdfjs_require__(97);
-
-var PROMISE = 'Promise';
-var TypeError = global.TypeError;
-var process = global.process;
-var versions = process && process.versions;
-var v8 = versions && versions.v8 || '';
-var $Promise = global[PROMISE];
-var isNode = classof(process) == 'process';
-
-var empty = function empty() {};
-
-var Internal, newGenericPromiseCapability, OwnPromiseCapability, Wrapper;
-var newPromiseCapability = newGenericPromiseCapability = newPromiseCapabilityModule.f;
-var USE_NATIVE = !!function () {
-  try {
-    var promise = $Promise.resolve(1);
-
-    var FakePromise = (promise.constructor = {})[__w_pdfjs_require__(33)('species')] = function (exec) {
-      exec(empty, empty);
-    };
-
-    return (isNode || typeof PromiseRejectionEvent == 'function') && promise.then(empty) instanceof FakePromise && v8.indexOf('6.6') !== 0 && userAgent.indexOf('Chrome/66') === -1;
-  } catch (e) {}
-}();
-
-var isThenable = function isThenable(it) {
-  var then;
-  return isObject(it) && typeof (then = it.then) == 'function' ? then : false;
-};
-
-var notify = function notify(promise, isReject) {
-  if (promise._n) return;
-  promise._n = true;
-  var chain = promise._c;
-  microtask(function () {
-    var value = promise._v;
-    var ok = promise._s == 1;
-    var i = 0;
-
-    var run = function run(reaction) {
-      var handler = ok ? reaction.ok : reaction.fail;
-      var resolve = reaction.resolve;
-      var reject = reaction.reject;
-      var domain = reaction.domain;
-      var result, then, exited;
-
-      try {
-        if (handler) {
-          if (!ok) {
-            if (promise._h == 2) onHandleUnhandled(promise);
-            promise._h = 1;
-          }
-
-          if (handler === true) result = value;else {
-            if (domain) domain.enter();
-            result = handler(value);
-
-            if (domain) {
-              domain.exit();
-              exited = true;
-            }
-          }
-
-          if (result === reaction.promise) {
-            reject(TypeError('Promise-chain cycle'));
-          } else if (then = isThenable(result)) {
-            then.call(result, resolve, reject);
-          } else resolve(result);
-        } else reject(value);
-      } catch (e) {
-        if (domain && !exited) domain.exit();
-        reject(e);
-      }
-    };
-
-    while (chain.length > i) {
-      run(chain[i++]);
-    }
-
-    promise._c = [];
-    promise._n = false;
-    if (isReject && !promise._h) onUnhandled(promise);
-  });
-};
-
-var onUnhandled = function onUnhandled(promise) {
-  task.call(global, function () {
-    var value = promise._v;
-    var unhandled = isUnhandled(promise);
-    var result, handler, console;
-
-    if (unhandled) {
-      result = perform(function () {
-        if (isNode) {
-          process.emit('unhandledRejection', value, promise);
-        } else if (handler = global.onunhandledrejection) {
-          handler({
-            promise: promise,
-            reason: value
-          });
-        } else if ((console = global.console) && console.error) {
-          console.error('Unhandled promise rejection', value);
-        }
-      });
-      promise._h = isNode || isUnhandled(promise) ? 2 : 1;
-    }
-
-    promise._a = undefined;
-    if (unhandled && result.e) throw result.v;
-  });
-};
-
-var isUnhandled = function isUnhandled(promise) {
-  return promise._h !== 1 && (promise._a || promise._c).length === 0;
-};
-
-var onHandleUnhandled = function onHandleUnhandled(promise) {
-  task.call(global, function () {
-    var handler;
-
-    if (isNode) {
-      process.emit('rejectionHandled', promise);
-    } else if (handler = global.onrejectionhandled) {
-      handler({
-        promise: promise,
-        reason: promise._v
-      });
-    }
-  });
-};
-
-var $reject = function $reject(value) {
-  var promise = this;
-  if (promise._d) return;
-  promise._d = true;
-  promise = promise._w || promise;
-  promise._v = value;
-  promise._s = 2;
-  if (!promise._a) promise._a = promise._c.slice();
-  notify(promise, true);
-};
-
-var $resolve = function $resolve(value) {
-  var promise = this;
-  var then;
-  if (promise._d) return;
-  promise._d = true;
-  promise = promise._w || promise;
-
-  try {
-    if (promise === value) throw TypeError("Promise can't be resolved itself");
-
-    if (then = isThenable(value)) {
-      microtask(function () {
-        var wrapper = {
-          _w: promise,
-          _d: false
-        };
-
-        try {
-          then.call(value, ctx($resolve, wrapper, 1), ctx($reject, wrapper, 1));
-        } catch (e) {
-          $reject.call(wrapper, e);
-        }
-      });
-    } else {
-      promise._v = value;
-      promise._s = 1;
-      notify(promise, false);
-    }
-  } catch (e) {
-    $reject.call({
-      _w: promise,
-      _d: false
-    }, e);
-  }
-};
-
-if (!USE_NATIVE) {
-  $Promise = function Promise(executor) {
-    anInstance(this, $Promise, PROMISE, '_h');
-    aFunction(executor);
-    Internal.call(this);
-
-    try {
-      executor(ctx($resolve, this, 1), ctx($reject, this, 1));
-    } catch (err) {
-      $reject.call(this, err);
-    }
-  };
-
-  Internal = function Promise(executor) {
-    this._c = [];
-    this._a = undefined;
-    this._s = 0;
-    this._d = false;
-    this._v = undefined;
-    this._h = 0;
-    this._n = false;
-  };
-
-  Internal.prototype = __w_pdfjs_require__(98)($Promise.prototype, {
-    then: function then(onFulfilled, onRejected) {
-      var reaction = newPromiseCapability(speciesConstructor(this, $Promise));
-      reaction.ok = typeof onFulfilled == 'function' ? onFulfilled : true;
-      reaction.fail = typeof onRejected == 'function' && onRejected;
-      reaction.domain = isNode ? process.domain : undefined;
-
-      this._c.push(reaction);
-
-      if (this._a) this._a.push(reaction);
-      if (this._s) notify(this, false);
-      return reaction.promise;
-    },
-    'catch': function _catch(onRejected) {
-      return this.then(undefined, onRejected);
-    }
-  });
-
-  OwnPromiseCapability = function OwnPromiseCapability() {
-    var promise = new Internal();
-    this.promise = promise;
-    this.resolve = ctx($resolve, promise, 1);
-    this.reject = ctx($reject, promise, 1);
-  };
-
-  newPromiseCapabilityModule.f = newPromiseCapability = function newPromiseCapability(C) {
-    return C === $Promise || C === Wrapper ? new OwnPromiseCapability(C) : newGenericPromiseCapability(C);
-  };
-}
-
-$export($export.G + $export.W + $export.F * !USE_NATIVE, {
-  Promise: $Promise
-});
-
-__w_pdfjs_require__(60)($Promise, PROMISE);
-
-__w_pdfjs_require__(99)(PROMISE);
-
-Wrapper = __w_pdfjs_require__(9)[PROMISE];
-$export($export.S + $export.F * !USE_NATIVE, PROMISE, {
-  reject: function reject(r) {
-    var capability = newPromiseCapability(this);
-    var $$reject = capability.reject;
-    $$reject(r);
-    return capability.promise;
-  }
-});
-$export($export.S + $export.F * (LIBRARY || !USE_NATIVE), PROMISE, {
-  resolve: function resolve(x) {
-    return promiseResolve(LIBRARY && this === Wrapper ? $Promise : this, x);
-  }
-});
-$export($export.S + $export.F * !(USE_NATIVE && __w_pdfjs_require__(69)(function (iter) {
-  $Promise.all(iter)['catch'](empty);
-})), PROMISE, {
-  all: function all(iterable) {
-    var C = this;
-    var capability = newPromiseCapability(C);
-    var resolve = capability.resolve;
-    var reject = capability.reject;
-    var result = perform(function () {
-      var values = [];
-      var index = 0;
-      var remaining = 1;
-      forOf(iterable, false, function (promise) {
-        var $index = index++;
-        var alreadyCalled = false;
-        values.push(undefined);
-        remaining++;
-        C.resolve(promise).then(function (value) {
-          if (alreadyCalled) return;
-          alreadyCalled = true;
-          values[$index] = value;
-          --remaining || resolve(values);
-        }, reject);
-      });
-      --remaining || resolve(values);
-    });
-    if (result.e) reject(result.v);
-    return capability.promise;
-  },
-  race: function race(iterable) {
-    var C = this;
-    var capability = newPromiseCapability(C);
-    var reject = capability.reject;
-    var result = perform(function () {
-      forOf(iterable, false, function (promise) {
-        C.resolve(promise).then(capability.resolve, reject);
-      });
-    });
-    if (result.e) reject(result.v);
-    return capability.promise;
-  }
-});
-
-/***/ }),
-/* 88 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-module.exports = function (it, Constructor, name, forbiddenField) {
-  if (!(it instanceof Constructor) || forbiddenField !== undefined && forbiddenField in it) {
-    throw TypeError(name + ': incorrect invocation!');
-  }
-
-  return it;
-};
-
-/***/ }),
-/* 89 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var ctx = __w_pdfjs_require__(26);
-
-var call = __w_pdfjs_require__(64);
-
-var isArrayIter = __w_pdfjs_require__(65);
-
-var anObject = __w_pdfjs_require__(12);
-
-var toLength = __w_pdfjs_require__(28);
-
-var getIterFn = __w_pdfjs_require__(67);
-
-var BREAK = {};
-var RETURN = {};
-
-var _exports = module.exports = function (iterable, entries, fn, that, ITERATOR) {
-  var iterFn = ITERATOR ? function () {
-    return iterable;
-  } : getIterFn(iterable);
-  var f = ctx(fn, that, entries ? 2 : 1);
-  var index = 0;
-  var length, step, iterator, result;
-  if (typeof iterFn != 'function') throw TypeError(iterable + ' is not iterable!');
-  if (isArrayIter(iterFn)) for (length = toLength(iterable.length); length > index; index++) {
-    result = entries ? f(anObject(step = iterable[index])[0], step[1]) : f(iterable[index]);
-    if (result === BREAK || result === RETURN) return result;
-  } else for (iterator = iterFn.call(iterable); !(step = iterator.next()).done;) {
-    result = call(iterator, f, step.value, entries);
-    if (result === BREAK || result === RETURN) return result;
-  }
-};
-
-_exports.BREAK = BREAK;
-_exports.RETURN = RETURN;
-
-/***/ }),
-/* 90 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var anObject = __w_pdfjs_require__(12);
-
-var aFunction = __w_pdfjs_require__(27);
-
-var SPECIES = __w_pdfjs_require__(33)('species');
-
-module.exports = function (O, D) {
-  var C = anObject(O).constructor;
-  var S;
-  return C === undefined || (S = anObject(C)[SPECIES]) == undefined ? D : aFunction(S);
-};
-
-/***/ }),
-/* 91 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var ctx = __w_pdfjs_require__(26);
-
-var invoke = __w_pdfjs_require__(92);
-
-var html = __w_pdfjs_require__(59);
-
-var cel = __w_pdfjs_require__(17);
-
-var global = __w_pdfjs_require__(8);
-
-var process = global.process;
-var setTask = global.setImmediate;
-var clearTask = global.clearImmediate;
-var MessageChannel = global.MessageChannel;
-var Dispatch = global.Dispatch;
-var counter = 0;
-var queue = {};
-var ONREADYSTATECHANGE = 'onreadystatechange';
-var defer, channel, port;
-
-var run = function run() {
-  var id = +this;
-
-  if (queue.hasOwnProperty(id)) {
-    var fn = queue[id];
-    delete queue[id];
-    fn();
-  }
-};
-
-var listener = function listener(event) {
-  run.call(event.data);
-};
-
-if (!setTask || !clearTask) {
-  setTask = function setImmediate(fn) {
-    var args = [];
-    var i = 1;
-
-    while (arguments.length > i) {
-      args.push(arguments[i++]);
-    }
-
-    queue[++counter] = function () {
-      invoke(typeof fn == 'function' ? fn : Function(fn), args);
-    };
-
-    defer(counter);
-    return counter;
-  };
-
-  clearTask = function clearImmediate(id) {
-    delete queue[id];
-  };
-
-  if (__w_pdfjs_require__(32)(process) == 'process') {
-    defer = function defer(id) {
-      process.nextTick(ctx(run, id, 1));
-    };
-  } else if (Dispatch && Dispatch.now) {
-    defer = function defer(id) {
-      Dispatch.now(ctx(run, id, 1));
-    };
-  } else if (MessageChannel) {
-    channel = new MessageChannel();
-    port = channel.port2;
-    channel.port1.onmessage = listener;
-    defer = ctx(port.postMessage, port, 1);
-  } else if (global.addEventListener && typeof postMessage == 'function' && !global.importScripts) {
-    defer = function defer(id) {
-      global.postMessage(id + '', '*');
-    };
-
-    global.addEventListener('message', listener, false);
-  } else if (ONREADYSTATECHANGE in cel('script')) {
-    defer = function defer(id) {
-      html.appendChild(cel('script'))[ONREADYSTATECHANGE] = function () {
-        html.removeChild(this);
-        run.call(id);
-      };
-    };
-  } else {
-    defer = function defer(id) {
-      setTimeout(ctx(run, id, 1), 0);
-    };
-  }
-}
-
-module.exports = {
-  set: setTask,
-  clear: clearTask
-};
-
-/***/ }),
-/* 92 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-module.exports = function (fn, args, that) {
-  var un = that === undefined;
-
-  switch (args.length) {
-    case 0:
-      return un ? fn() : fn.call(that);
-
-    case 1:
-      return un ? fn(args[0]) : fn.call(that, args[0]);
-
-    case 2:
-      return un ? fn(args[0], args[1]) : fn.call(that, args[0], args[1]);
-
-    case 3:
-      return un ? fn(args[0], args[1], args[2]) : fn.call(that, args[0], args[1], args[2]);
-
-    case 4:
-      return un ? fn(args[0], args[1], args[2], args[3]) : fn.call(that, args[0], args[1], args[2], args[3]);
-  }
-
-  return fn.apply(that, args);
-};
-
-/***/ }),
-/* 93 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var global = __w_pdfjs_require__(8);
-
-var macrotask = __w_pdfjs_require__(91).set;
-
-var Observer = global.MutationObserver || global.WebKitMutationObserver;
-var process = global.process;
-var Promise = global.Promise;
-var isNode = __w_pdfjs_require__(32)(process) == 'process';
-
-module.exports = function () {
-  var head, last, notify;
-
-  var flush = function flush() {
-    var parent, fn;
-    if (isNode && (parent = process.domain)) parent.exit();
-
-    while (head) {
-      fn = head.fn;
-      head = head.next;
-
-      try {
-        fn();
-      } catch (e) {
-        if (head) notify();else last = undefined;
-        throw e;
-      }
-    }
-
-    last = undefined;
-    if (parent) parent.enter();
-  };
-
-  if (isNode) {
-    notify = function notify() {
-      process.nextTick(flush);
-    };
-  } else if (Observer && !(global.navigator && global.navigator.standalone)) {
-    var toggle = true;
-    var node = document.createTextNode('');
-    new Observer(flush).observe(node, {
-      characterData: true
-    });
-
-    notify = function notify() {
-      node.data = toggle = !toggle;
-    };
-  } else if (Promise && Promise.resolve) {
-    var promise = Promise.resolve(undefined);
-
-    notify = function notify() {
-      promise.then(flush);
-    };
-  } else {
-    notify = function notify() {
-      macrotask.call(global, flush);
-    };
-  }
-
-  return function (fn) {
-    var task = {
-      fn: fn,
-      next: undefined
-    };
-    if (last) last.next = task;
-
-    if (!head) {
-      head = task;
-      notify();
-    }
-
-    last = task;
-  };
-};
-
-/***/ }),
-/* 94 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var aFunction = __w_pdfjs_require__(27);
-
-function PromiseCapability(C) {
-  var resolve, reject;
-  this.promise = new C(function ($$resolve, $$reject) {
-    if (resolve !== undefined || reject !== undefined) throw TypeError('Bad Promise constructor');
-    resolve = $$resolve;
-    reject = $$reject;
-  });
-  this.resolve = aFunction(resolve);
-  this.reject = aFunction(reject);
-}
-
-module.exports.f = function (C) {
-  return new PromiseCapability(C);
-};
-
-/***/ }),
-/* 95 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-module.exports = function (exec) {
-  try {
-    return {
-      e: false,
-      v: exec()
-    };
-  } catch (e) {
-    return {
-      e: true,
-      v: e
-    };
-  }
-};
-
-/***/ }),
-/* 96 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var global = __w_pdfjs_require__(8);
-
-var navigator = global.navigator;
-module.exports = navigator && navigator.userAgent || '';
-
-/***/ }),
-/* 97 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var anObject = __w_pdfjs_require__(12);
-
-var isObject = __w_pdfjs_require__(13);
-
-var newPromiseCapability = __w_pdfjs_require__(94);
-
-module.exports = function (C, x) {
-  anObject(C);
-  if (isObject(x) && x.constructor === C) return x;
-  var promiseCapability = newPromiseCapability.f(C);
-  var resolve = promiseCapability.resolve;
-  resolve(x);
-  return promiseCapability.promise;
-};
-
-/***/ }),
-/* 98 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var redefine = __w_pdfjs_require__(20);
-
-module.exports = function (target, src, safe) {
-  for (var key in src) {
-    redefine(target, key, src[key], safe);
-  }
-
-  return target;
-};
-
-/***/ }),
-/* 99 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var global = __w_pdfjs_require__(8);
-
-var dP = __w_pdfjs_require__(11);
-
-var DESCRIPTORS = __w_pdfjs_require__(15);
-
-var SPECIES = __w_pdfjs_require__(33)('species');
-
-module.exports = function (KEY) {
-  var C = global[KEY];
-  if (DESCRIPTORS && C && !C[SPECIES]) dP.f(C, SPECIES, {
-    configurable: true,
-    get: function get() {
-      return this;
-    }
-  });
-};
-
-/***/ }),
-/* 100 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $export = __w_pdfjs_require__(7);
-
-var core = __w_pdfjs_require__(9);
-
-var global = __w_pdfjs_require__(8);
-
-var speciesConstructor = __w_pdfjs_require__(90);
-
-var promiseResolve = __w_pdfjs_require__(97);
-
-$export($export.P + $export.R, 'Promise', {
-  'finally': function _finally(onFinally) {
-    var C = speciesConstructor(this, core.Promise || global.Promise);
-    var isFunction = typeof onFinally == 'function';
-    return this.then(isFunction ? function (x) {
-      return promiseResolve(C, onFinally()).then(function () {
-        return x;
-      });
-    } : onFinally, isFunction ? function (e) {
-      return promiseResolve(C, onFinally()).then(function () {
-        throw e;
-      });
-    } : onFinally);
-  }
-});
-
-/***/ }),
-/* 101 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $export = __w_pdfjs_require__(7);
-
-var newPromiseCapability = __w_pdfjs_require__(94);
-
-var perform = __w_pdfjs_require__(95);
-
-$export($export.S, 'Promise', {
-  'try': function _try(callbackfn) {
-    var promiseCapability = newPromiseCapability.f(this);
-    var result = perform(callbackfn);
-    (result.e ? promiseCapability.reject : promiseCapability.resolve)(result.v);
-    return promiseCapability.promise;
-  }
-});
-
-/***/ }),
-/* 102 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(83);
-
-__w_pdfjs_require__(84);
-
-__w_pdfjs_require__(103);
-
-__w_pdfjs_require__(115);
-
-__w_pdfjs_require__(117);
-
-module.exports = __w_pdfjs_require__(9).WeakMap;
-
-/***/ }),
-/* 103 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var global = __w_pdfjs_require__(8);
-
-var each = __w_pdfjs_require__(104)(0);
-
-var redefine = __w_pdfjs_require__(20);
-
-var meta = __w_pdfjs_require__(108);
-
-var assign = __w_pdfjs_require__(72);
-
-var weak = __w_pdfjs_require__(109);
-
-var isObject = __w_pdfjs_require__(13);
-
-var validate = __w_pdfjs_require__(110);
-
-var NATIVE_WEAK_MAP = __w_pdfjs_require__(110);
-
-var IS_IE11 = !global.ActiveXObject && 'ActiveXObject' in global;
-var WEAK_MAP = 'WeakMap';
-var getWeak = meta.getWeak;
-var isExtensible = Object.isExtensible;
-var uncaughtFrozenStore = weak.ufstore;
-var InternalMap;
-
-var wrapper = function wrapper(get) {
-  return function WeakMap() {
-    return get(this, arguments.length > 0 ? arguments[0] : undefined);
-  };
-};
-
-var methods = {
-  get: function get(key) {
-    if (isObject(key)) {
-      var data = getWeak(key);
-      if (data === true) return uncaughtFrozenStore(validate(this, WEAK_MAP)).get(key);
-      return data ? data[this._i] : undefined;
-    }
-  },
-  set: function set(key, value) {
-    return weak.def(validate(this, WEAK_MAP), key, value);
-  }
-};
-
-var $WeakMap = module.exports = __w_pdfjs_require__(111)(WEAK_MAP, wrapper, methods, weak, true, true);
-
-if (NATIVE_WEAK_MAP && IS_IE11) {
-  InternalMap = weak.getConstructor(wrapper, WEAK_MAP);
-  assign(InternalMap.prototype, methods);
-  meta.NEED = true;
-  each(['delete', 'has', 'get', 'set'], function (key) {
-    var proto = $WeakMap.prototype;
-    var method = proto[key];
-    redefine(proto, key, function (a, b) {
-      if (isObject(a) && !isExtensible(a)) {
-        if (!this._f) this._f = new InternalMap();
-
-        var result = this._f[key](a, b);
-
-        return key == 'set' ? this : result;
-      }
-
-      return method.call(this, a, b);
-    });
-  });
-}
-
-/***/ }),
-/* 104 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var ctx = __w_pdfjs_require__(26);
-
-var IObject = __w_pdfjs_require__(44);
-
-var toObject = __w_pdfjs_require__(62);
-
-var toLength = __w_pdfjs_require__(28);
-
-var asc = __w_pdfjs_require__(105);
-
-module.exports = function (TYPE, $create) {
-  var IS_MAP = TYPE == 1;
-  var IS_FILTER = TYPE == 2;
-  var IS_SOME = TYPE == 3;
-  var IS_EVERY = TYPE == 4;
-  var IS_FIND_INDEX = TYPE == 6;
-  var NO_HOLES = TYPE == 5 || IS_FIND_INDEX;
-  var create = $create || asc;
-  return function ($this, callbackfn, that) {
-    var O = toObject($this);
-    var self = IObject(O);
-    var f = ctx(callbackfn, that, 3);
-    var length = toLength(self.length);
-    var index = 0;
-    var result = IS_MAP ? create($this, length) : IS_FILTER ? create($this, 0) : undefined;
-    var val, res;
-
-    for (; length > index; index++) {
-      if (NO_HOLES || index in self) {
-        val = self[index];
-        res = f(val, index, O);
-
-        if (TYPE) {
-          if (IS_MAP) result[index] = res;else if (res) switch (TYPE) {
-            case 3:
-              return true;
-
-            case 5:
-              return val;
-
-            case 6:
-              return index;
-
-            case 2:
-              result.push(val);
-          } else if (IS_EVERY) return false;
-        }
-      }
-    }
-
-    return IS_FIND_INDEX ? -1 : IS_SOME || IS_EVERY ? IS_EVERY : result;
-  };
-};
-
-/***/ }),
-/* 105 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var speciesConstructor = __w_pdfjs_require__(106);
-
-module.exports = function (original, length) {
-  return new (speciesConstructor(original))(length);
-};
-
-/***/ }),
-/* 106 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var isObject = __w_pdfjs_require__(13);
-
-var isArray = __w_pdfjs_require__(107);
-
-var SPECIES = __w_pdfjs_require__(33)('species');
-
-module.exports = function (original) {
-  var C;
-
-  if (isArray(original)) {
-    C = original.constructor;
-    if (typeof C == 'function' && (C === Array || isArray(C.prototype))) C = undefined;
-
-    if (isObject(C)) {
-      C = C[SPECIES];
-      if (C === null) C = undefined;
-    }
-  }
-
-  return C === undefined ? Array : C;
-};
-
-/***/ }),
-/* 107 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var cof = __w_pdfjs_require__(32);
-
-module.exports = Array.isArray || function isArray(arg) {
-  return cof(arg) == 'Array';
-};
-
-/***/ }),
-/* 108 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-var META = __w_pdfjs_require__(22)('meta');
-
-var isObject = __w_pdfjs_require__(13);
-
-var has = __w_pdfjs_require__(21);
-
-var setDesc = __w_pdfjs_require__(11).f;
-
-var id = 0;
-
-var isExtensible = Object.isExtensible || function () {
-  return true;
-};
-
-var FREEZE = !__w_pdfjs_require__(16)(function () {
-  return isExtensible(Object.preventExtensions({}));
-});
-
-var setMeta = function setMeta(it) {
-  setDesc(it, META, {
-    value: {
-      i: 'O' + ++id,
-      w: {}
-    }
-  });
-};
-
-var fastKey = function fastKey(it, create) {
-  if (!isObject(it)) return _typeof(it) == 'symbol' ? it : (typeof it == 'string' ? 'S' : 'P') + it;
-
-  if (!has(it, META)) {
-    if (!isExtensible(it)) return 'F';
-    if (!create) return 'E';
-    setMeta(it);
-  }
-
-  return it[META].i;
-};
-
-var getWeak = function getWeak(it, create) {
-  if (!has(it, META)) {
-    if (!isExtensible(it)) return true;
-    if (!create) return false;
-    setMeta(it);
-  }
-
-  return it[META].w;
-};
-
-var onFreeze = function onFreeze(it) {
-  if (FREEZE && meta.NEED && isExtensible(it) && !has(it, META)) setMeta(it);
-  return it;
-};
-
-var meta = module.exports = {
-  KEY: META,
-  NEED: false,
-  fastKey: fastKey,
-  getWeak: getWeak,
-  onFreeze: onFreeze
-};
-
-/***/ }),
-/* 109 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var redefineAll = __w_pdfjs_require__(98);
-
-var getWeak = __w_pdfjs_require__(108).getWeak;
-
-var anObject = __w_pdfjs_require__(12);
-
-var isObject = __w_pdfjs_require__(13);
-
-var anInstance = __w_pdfjs_require__(88);
-
-var forOf = __w_pdfjs_require__(89);
-
-var createArrayMethod = __w_pdfjs_require__(104);
-
-var $has = __w_pdfjs_require__(21);
-
-var validate = __w_pdfjs_require__(110);
-
-var arrayFind = createArrayMethod(5);
-var arrayFindIndex = createArrayMethod(6);
-var id = 0;
-
-var uncaughtFrozenStore = function uncaughtFrozenStore(that) {
-  return that._l || (that._l = new UncaughtFrozenStore());
-};
-
-var UncaughtFrozenStore = function UncaughtFrozenStore() {
-  this.a = [];
-};
-
-var findUncaughtFrozen = function findUncaughtFrozen(store, key) {
-  return arrayFind(store.a, function (it) {
-    return it[0] === key;
-  });
-};
-
-UncaughtFrozenStore.prototype = {
-  get: function get(key) {
-    var entry = findUncaughtFrozen(this, key);
-    if (entry) return entry[1];
-  },
-  has: function has(key) {
-    return !!findUncaughtFrozen(this, key);
-  },
-  set: function set(key, value) {
-    var entry = findUncaughtFrozen(this, key);
-    if (entry) entry[1] = value;else this.a.push([key, value]);
-  },
-  'delete': function _delete(key) {
-    var index = arrayFindIndex(this.a, function (it) {
-      return it[0] === key;
-    });
-    if (~index) this.a.splice(index, 1);
-    return !!~index;
-  }
-};
-module.exports = {
-  getConstructor: function getConstructor(wrapper, NAME, IS_MAP, ADDER) {
-    var C = wrapper(function (that, iterable) {
-      anInstance(that, C, NAME, '_i');
-      that._t = NAME;
-      that._i = id++;
-      that._l = undefined;
-      if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);
-    });
-    redefineAll(C.prototype, {
-      'delete': function _delete(key) {
-        if (!isObject(key)) return false;
-        var data = getWeak(key);
-        if (data === true) return uncaughtFrozenStore(validate(this, NAME))['delete'](key);
-        return data && $has(data, this._i) && delete data[this._i];
-      },
-      has: function has(key) {
-        if (!isObject(key)) return false;
-        var data = getWeak(key);
-        if (data === true) return uncaughtFrozenStore(validate(this, NAME)).has(key);
-        return data && $has(data, this._i);
-      }
-    });
-    return C;
-  },
-  def: function def(that, key, value) {
-    var data = getWeak(anObject(key), true);
-    if (data === true) uncaughtFrozenStore(that).set(key, value);else data[that._i] = value;
-    return that;
-  },
-  ufstore: uncaughtFrozenStore
-};
-
-/***/ }),
-/* 110 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var isObject = __w_pdfjs_require__(13);
-
-module.exports = function (it, TYPE) {
-  if (!isObject(it) || it._t !== TYPE) throw TypeError('Incompatible receiver, ' + TYPE + ' required!');
-  return it;
-};
-
-/***/ }),
-/* 111 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var global = __w_pdfjs_require__(8);
-
-var $export = __w_pdfjs_require__(7);
-
-var redefine = __w_pdfjs_require__(20);
-
-var redefineAll = __w_pdfjs_require__(98);
-
-var meta = __w_pdfjs_require__(108);
-
-var forOf = __w_pdfjs_require__(89);
-
-var anInstance = __w_pdfjs_require__(88);
-
-var isObject = __w_pdfjs_require__(13);
-
-var fails = __w_pdfjs_require__(16);
-
-var $iterDetect = __w_pdfjs_require__(69);
-
-var setToStringTag = __w_pdfjs_require__(60);
-
-var inheritIfRequired = __w_pdfjs_require__(112);
-
-module.exports = function (NAME, wrapper, methods, common, IS_MAP, IS_WEAK) {
-  var Base = global[NAME];
-  var C = Base;
-  var ADDER = IS_MAP ? 'set' : 'add';
-  var proto = C && C.prototype;
-  var O = {};
-
-  var fixMethod = function fixMethod(KEY) {
-    var fn = proto[KEY];
-    redefine(proto, KEY, KEY == 'delete' ? function (a) {
-      return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
-    } : KEY == 'has' ? function has(a) {
-      return IS_WEAK && !isObject(a) ? false : fn.call(this, a === 0 ? 0 : a);
-    } : KEY == 'get' ? function get(a) {
-      return IS_WEAK && !isObject(a) ? undefined : fn.call(this, a === 0 ? 0 : a);
-    } : KEY == 'add' ? function add(a) {
-      fn.call(this, a === 0 ? 0 : a);
-      return this;
-    } : function set(a, b) {
-      fn.call(this, a === 0 ? 0 : a, b);
-      return this;
-    });
-  };
-
-  if (typeof C != 'function' || !(IS_WEAK || proto.forEach && !fails(function () {
-    new C().entries().next();
-  }))) {
-    C = common.getConstructor(wrapper, NAME, IS_MAP, ADDER);
-    redefineAll(C.prototype, methods);
-    meta.NEED = true;
-  } else {
-    var instance = new C();
-    var HASNT_CHAINING = instance[ADDER](IS_WEAK ? {} : -0, 1) != instance;
-    var THROWS_ON_PRIMITIVES = fails(function () {
-      instance.has(1);
-    });
-    var ACCEPT_ITERABLES = $iterDetect(function (iter) {
-      new C(iter);
-    });
-    var BUGGY_ZERO = !IS_WEAK && fails(function () {
-      var $instance = new C();
-      var index = 5;
-
-      while (index--) {
-        $instance[ADDER](index, index);
-      }
-
-      return !$instance.has(-0);
-    });
-
-    if (!ACCEPT_ITERABLES) {
-      C = wrapper(function (target, iterable) {
-        anInstance(target, C, NAME);
-        var that = inheritIfRequired(new Base(), target, C);
-        if (iterable != undefined) forOf(iterable, IS_MAP, that[ADDER], that);
-        return that;
-      });
-      C.prototype = proto;
-      proto.constructor = C;
-    }
-
-    if (THROWS_ON_PRIMITIVES || BUGGY_ZERO) {
-      fixMethod('delete');
-      fixMethod('has');
-      IS_MAP && fixMethod('get');
-    }
-
-    if (BUGGY_ZERO || HASNT_CHAINING) fixMethod(ADDER);
-    if (IS_WEAK && proto.clear) delete proto.clear;
-  }
-
-  setToStringTag(C, NAME);
-  O[NAME] = C;
-  $export($export.G + $export.W + $export.F * (C != Base), O);
-  if (!IS_WEAK) common.setStrong(C, NAME, IS_MAP);
-  return C;
-};
-
-/***/ }),
-/* 112 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var isObject = __w_pdfjs_require__(13);
-
-var setPrototypeOf = __w_pdfjs_require__(113).set;
-
-module.exports = function (that, target, C) {
-  var S = target.constructor;
-  var P;
-
-  if (S !== C && typeof S == 'function' && (P = S.prototype) !== C.prototype && isObject(P) && setPrototypeOf) {
-    setPrototypeOf(that, P);
-  }
-
-  return that;
-};
-
-/***/ }),
-/* 113 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var isObject = __w_pdfjs_require__(13);
-
-var anObject = __w_pdfjs_require__(12);
-
-var check = function check(O, proto) {
-  anObject(O);
-  if (!isObject(proto) && proto !== null) throw TypeError(proto + ": can't set as prototype!");
-};
-
-module.exports = {
-  set: Object.setPrototypeOf || ('__proto__' in {} ? function (test, buggy, set) {
-    try {
-      set = __w_pdfjs_require__(26)(Function.call, __w_pdfjs_require__(114).f(Object.prototype, '__proto__').set, 2);
-      set(test, []);
-      buggy = !(test instanceof Array);
-    } catch (e) {
-      buggy = true;
-    }
-
-    return function setPrototypeOf(O, proto) {
-      check(O, proto);
-      if (buggy) O.__proto__ = proto;else set(O, proto);
-      return O;
-    };
-  }({}, false) : undefined),
-  check: check
-};
-
-/***/ }),
-/* 114 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var pIE = __w_pdfjs_require__(74);
-
-var createDesc = __w_pdfjs_require__(19);
-
-var toIObject = __w_pdfjs_require__(43);
-
-var toPrimitive = __w_pdfjs_require__(18);
-
-var has = __w_pdfjs_require__(21);
-
-var IE8_DOM_DEFINE = __w_pdfjs_require__(14);
-
-var gOPD = Object.getOwnPropertyDescriptor;
-exports.f = __w_pdfjs_require__(15) ? gOPD : function getOwnPropertyDescriptor(O, P) {
-  O = toIObject(O);
-  P = toPrimitive(P, true);
-  if (IE8_DOM_DEFINE) try {
-    return gOPD(O, P);
-  } catch (e) {}
-  if (has(O, P)) return createDesc(!pIE.f.call(O, P), O[P]);
-};
-
-/***/ }),
-/* 115 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(116)('WeakMap');
-
-/***/ }),
-/* 116 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $export = __w_pdfjs_require__(7);
-
-module.exports = function (COLLECTION) {
-  $export($export.S, COLLECTION, {
-    of: function of() {
-      var length = arguments.length;
-      var A = new Array(length);
-
-      while (length--) {
-        A[length] = arguments[length];
-      }
-
-      return new this(A);
-    }
-  });
-};
-
-/***/ }),
-/* 117 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(118)('WeakMap');
-
-/***/ }),
-/* 118 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $export = __w_pdfjs_require__(7);
-
-var aFunction = __w_pdfjs_require__(27);
-
-var ctx = __w_pdfjs_require__(26);
-
-var forOf = __w_pdfjs_require__(89);
-
-module.exports = function (COLLECTION) {
-  $export($export.S, COLLECTION, {
-    from: function from(source) {
-      var mapFn = arguments[1];
-      var mapping, A, n, cb;
-      aFunction(this);
-      mapping = mapFn !== undefined;
-      if (mapping) aFunction(mapFn);
-      if (source == undefined) return new this();
-      A = [];
-
-      if (mapping) {
-        n = 0;
-        cb = ctx(mapFn, arguments[2], 2);
-        forOf(source, false, function (nextItem) {
-          A.push(cb(nextItem, n++));
-        });
-      } else {
-        forOf(source, false, A.push, A);
-      }
-
-      return new this(A);
-    }
-  });
-};
-
-/***/ }),
-/* 119 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(83);
-
-__w_pdfjs_require__(84);
-
-__w_pdfjs_require__(120);
-
-__w_pdfjs_require__(121);
-
-__w_pdfjs_require__(122);
-
-module.exports = __w_pdfjs_require__(9).WeakSet;
-
-/***/ }),
-/* 120 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var weak = __w_pdfjs_require__(109);
-
-var validate = __w_pdfjs_require__(110);
-
-var WEAK_SET = 'WeakSet';
-
-__w_pdfjs_require__(111)(WEAK_SET, function (get) {
-  return function WeakSet() {
-    return get(this, arguments.length > 0 ? arguments[0] : undefined);
-  };
-}, {
-  add: function add(value) {
-    return weak.def(validate(this, WEAK_SET), value, true);
-  }
-}, weak, false, true);
-
-/***/ }),
-/* 121 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(116)('WeakSet');
-
-/***/ }),
-/* 122 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(118)('WeakSet');
-
-/***/ }),
-/* 123 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(124);
-
-module.exports = __w_pdfjs_require__(9).String.codePointAt;
-
-/***/ }),
-/* 124 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $export = __w_pdfjs_require__(7);
-
-var $at = __w_pdfjs_require__(49)(false);
-
-$export($export.P, 'String', {
-  codePointAt: function codePointAt(pos) {
-    return $at(this, pos);
-  }
-});
-
-/***/ }),
-/* 125 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(126);
-
-module.exports = __w_pdfjs_require__(9).String.fromCodePoint;
-
-/***/ }),
-/* 126 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $export = __w_pdfjs_require__(7);
-
-var toAbsoluteIndex = __w_pdfjs_require__(45);
-
-var fromCharCode = String.fromCharCode;
-var $fromCodePoint = String.fromCodePoint;
-$export($export.S + $export.F * (!!$fromCodePoint && $fromCodePoint.length != 1), 'String', {
-  fromCodePoint: function fromCodePoint(x) {
-    var res = [];
-    var aLen = arguments.length;
-    var i = 0;
-    var code;
-
-    while (aLen > i) {
-      code = +arguments[i++];
-      if (toAbsoluteIndex(code, 0x10ffff) !== code) throw RangeError(code + ' is not a valid code point');
-      res.push(code < 0x10000 ? fromCharCode(code) : fromCharCode(((code -= 0x10000) >> 10) + 0xd800, code % 0x400 + 0xdc00));
-    }
-
-    return res.join('');
-  }
-});
-
-/***/ }),
-/* 127 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(128);
-
-__w_pdfjs_require__(83);
-
-module.exports = __w_pdfjs_require__(9).Symbol;
-
-/***/ }),
-/* 128 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-var global = __w_pdfjs_require__(8);
-
-var has = __w_pdfjs_require__(21);
-
-var DESCRIPTORS = __w_pdfjs_require__(15);
-
-var $export = __w_pdfjs_require__(7);
-
-var redefine = __w_pdfjs_require__(20);
-
-var META = __w_pdfjs_require__(108).KEY;
-
-var $fails = __w_pdfjs_require__(16);
-
-var shared = __w_pdfjs_require__(24);
-
-var setToStringTag = __w_pdfjs_require__(60);
-
-var uid = __w_pdfjs_require__(22);
-
-var wks = __w_pdfjs_require__(33);
-
-var wksExt = __w_pdfjs_require__(129);
-
-var wksDefine = __w_pdfjs_require__(130);
-
-var enumKeys = __w_pdfjs_require__(131);
-
-var isArray = __w_pdfjs_require__(107);
-
-var anObject = __w_pdfjs_require__(12);
-
-var isObject = __w_pdfjs_require__(13);
-
-var toObject = __w_pdfjs_require__(62);
-
-var toIObject = __w_pdfjs_require__(43);
-
-var toPrimitive = __w_pdfjs_require__(18);
-
-var createDesc = __w_pdfjs_require__(19);
-
-var _create = __w_pdfjs_require__(53);
-
-var gOPNExt = __w_pdfjs_require__(132);
-
-var $GOPD = __w_pdfjs_require__(114);
-
-var $GOPS = __w_pdfjs_require__(73);
-
-var $DP = __w_pdfjs_require__(11);
-
-var $keys = __w_pdfjs_require__(55);
-
-var gOPD = $GOPD.f;
-var dP = $DP.f;
-var gOPN = gOPNExt.f;
-var $Symbol = global.Symbol;
-var $JSON = global.JSON;
-
-var _stringify = $JSON && $JSON.stringify;
-
-var PROTOTYPE = 'prototype';
-var HIDDEN = wks('_hidden');
-var TO_PRIMITIVE = wks('toPrimitive');
-var isEnum = {}.propertyIsEnumerable;
-var SymbolRegistry = shared('symbol-registry');
-var AllSymbols = shared('symbols');
-var OPSymbols = shared('op-symbols');
-var ObjectProto = Object[PROTOTYPE];
-var USE_NATIVE = typeof $Symbol == 'function' && !!$GOPS.f;
-var QObject = global.QObject;
-var setter = !QObject || !QObject[PROTOTYPE] || !QObject[PROTOTYPE].findChild;
-var setSymbolDesc = DESCRIPTORS && $fails(function () {
-  return _create(dP({}, 'a', {
-    get: function get() {
-      return dP(this, 'a', {
-        value: 7
-      }).a;
-    }
-  })).a != 7;
-}) ? function (it, key, D) {
-  var protoDesc = gOPD(ObjectProto, key);
-  if (protoDesc) delete ObjectProto[key];
-  dP(it, key, D);
-  if (protoDesc && it !== ObjectProto) dP(ObjectProto, key, protoDesc);
-} : dP;
-
-var wrap = function wrap(tag) {
-  var sym = AllSymbols[tag] = _create($Symbol[PROTOTYPE]);
-
-  sym._k = tag;
-  return sym;
-};
-
-var isSymbol = USE_NATIVE && _typeof($Symbol.iterator) == 'symbol' ? function (it) {
-  return _typeof(it) == 'symbol';
-} : function (it) {
-  return it instanceof $Symbol;
-};
-
-var $defineProperty = function defineProperty(it, key, D) {
-  if (it === ObjectProto) $defineProperty(OPSymbols, key, D);
-  anObject(it);
-  key = toPrimitive(key, true);
-  anObject(D);
-
-  if (has(AllSymbols, key)) {
-    if (!D.enumerable) {
-      if (!has(it, HIDDEN)) dP(it, HIDDEN, createDesc(1, {}));
-      it[HIDDEN][key] = true;
-    } else {
-      if (has(it, HIDDEN) && it[HIDDEN][key]) it[HIDDEN][key] = false;
-      D = _create(D, {
-        enumerable: createDesc(0, false)
-      });
-    }
-
-    return setSymbolDesc(it, key, D);
-  }
-
-  return dP(it, key, D);
-};
-
-var $defineProperties = function defineProperties(it, P) {
-  anObject(it);
-  var keys = enumKeys(P = toIObject(P));
-  var i = 0;
-  var l = keys.length;
-  var key;
-
-  while (l > i) {
-    $defineProperty(it, key = keys[i++], P[key]);
-  }
-
-  return it;
-};
-
-var $create = function create(it, P) {
-  return P === undefined ? _create(it) : $defineProperties(_create(it), P);
-};
-
-var $propertyIsEnumerable = function propertyIsEnumerable(key) {
-  var E = isEnum.call(this, key = toPrimitive(key, true));
-  if (this === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return false;
-  return E || !has(this, key) || !has(AllSymbols, key) || has(this, HIDDEN) && this[HIDDEN][key] ? E : true;
-};
-
-var $getOwnPropertyDescriptor = function getOwnPropertyDescriptor(it, key) {
-  it = toIObject(it);
-  key = toPrimitive(key, true);
-  if (it === ObjectProto && has(AllSymbols, key) && !has(OPSymbols, key)) return;
-  var D = gOPD(it, key);
-  if (D && has(AllSymbols, key) && !(has(it, HIDDEN) && it[HIDDEN][key])) D.enumerable = true;
-  return D;
-};
-
-var $getOwnPropertyNames = function getOwnPropertyNames(it) {
-  var names = gOPN(toIObject(it));
-  var result = [];
-  var i = 0;
-  var key;
-
-  while (names.length > i) {
-    if (!has(AllSymbols, key = names[i++]) && key != HIDDEN && key != META) result.push(key);
-  }
-
-  return result;
-};
-
-var $getOwnPropertySymbols = function getOwnPropertySymbols(it) {
-  var IS_OP = it === ObjectProto;
-  var names = gOPN(IS_OP ? OPSymbols : toIObject(it));
-  var result = [];
-  var i = 0;
-  var key;
-
-  while (names.length > i) {
-    if (has(AllSymbols, key = names[i++]) && (IS_OP ? has(ObjectProto, key) : true)) result.push(AllSymbols[key]);
-  }
-
-  return result;
-};
-
-if (!USE_NATIVE) {
-  $Symbol = function _Symbol() {
-    if (this instanceof $Symbol) throw TypeError('Symbol is not a constructor!');
-    var tag = uid(arguments.length > 0 ? arguments[0] : undefined);
-
-    var $set = function $set(value) {
-      if (this === ObjectProto) $set.call(OPSymbols, value);
-      if (has(this, HIDDEN) && has(this[HIDDEN], tag)) this[HIDDEN][tag] = false;
-      setSymbolDesc(this, tag, createDesc(1, value));
-    };
-
-    if (DESCRIPTORS && setter) setSymbolDesc(ObjectProto, tag, {
-      configurable: true,
-      set: $set
-    });
-    return wrap(tag);
-  };
-
-  redefine($Symbol[PROTOTYPE], 'toString', function toString() {
-    return this._k;
-  });
-  $GOPD.f = $getOwnPropertyDescriptor;
-  $DP.f = $defineProperty;
-  __w_pdfjs_require__(133).f = gOPNExt.f = $getOwnPropertyNames;
-  __w_pdfjs_require__(74).f = $propertyIsEnumerable;
-  $GOPS.f = $getOwnPropertySymbols;
-
-  if (DESCRIPTORS && !__w_pdfjs_require__(25)) {
-    redefine(ObjectProto, 'propertyIsEnumerable', $propertyIsEnumerable, true);
-  }
-
-  wksExt.f = function (name) {
-    return wrap(wks(name));
-  };
-}
-
-$export($export.G + $export.W + $export.F * !USE_NATIVE, {
-  Symbol: $Symbol
-});
-
-for (var es6Symbols = 'hasInstance,isConcatSpreadable,iterator,match,replace,search,species,split,toPrimitive,toStringTag,unscopables'.split(','), j = 0; es6Symbols.length > j;) {
-  wks(es6Symbols[j++]);
-}
-
-for (var wellKnownSymbols = $keys(wks.store), k = 0; wellKnownSymbols.length > k;) {
-  wksDefine(wellKnownSymbols[k++]);
-}
-
-$export($export.S + $export.F * !USE_NATIVE, 'Symbol', {
-  'for': function _for(key) {
-    return has(SymbolRegistry, key += '') ? SymbolRegistry[key] : SymbolRegistry[key] = $Symbol(key);
-  },
-  keyFor: function keyFor(sym) {
-    if (!isSymbol(sym)) throw TypeError(sym + ' is not a symbol!');
-
-    for (var key in SymbolRegistry) {
-      if (SymbolRegistry[key] === sym) return key;
-    }
-  },
-  useSetter: function useSetter() {
-    setter = true;
-  },
-  useSimple: function useSimple() {
-    setter = false;
-  }
-});
-$export($export.S + $export.F * !USE_NATIVE, 'Object', {
-  create: $create,
-  defineProperty: $defineProperty,
-  defineProperties: $defineProperties,
-  getOwnPropertyDescriptor: $getOwnPropertyDescriptor,
-  getOwnPropertyNames: $getOwnPropertyNames,
-  getOwnPropertySymbols: $getOwnPropertySymbols
-});
-var FAILS_ON_PRIMITIVES = $fails(function () {
-  $GOPS.f(1);
-});
-$export($export.S + $export.F * FAILS_ON_PRIMITIVES, 'Object', {
-  getOwnPropertySymbols: function getOwnPropertySymbols(it) {
-    return $GOPS.f(toObject(it));
-  }
-});
-$JSON && $export($export.S + $export.F * (!USE_NATIVE || $fails(function () {
-  var S = $Symbol();
-  return _stringify([S]) != '[null]' || _stringify({
-    a: S
-  }) != '{}' || _stringify(Object(S)) != '{}';
-})), 'JSON', {
-  stringify: function stringify(it) {
-    var args = [it];
-    var i = 1;
-    var replacer, $replacer;
-
-    while (arguments.length > i) {
-      args.push(arguments[i++]);
-    }
-
-    $replacer = replacer = args[1];
-    if (!isObject(replacer) && it === undefined || isSymbol(it)) return;
-    if (!isArray(replacer)) replacer = function replacer(key, value) {
-      if (typeof $replacer == 'function') value = $replacer.call(this, key, value);
-      if (!isSymbol(value)) return value;
-    };
-    args[1] = replacer;
-    return _stringify.apply($JSON, args);
-  }
-});
-$Symbol[PROTOTYPE][TO_PRIMITIVE] || __w_pdfjs_require__(10)($Symbol[PROTOTYPE], TO_PRIMITIVE, $Symbol[PROTOTYPE].valueOf);
-setToStringTag($Symbol, 'Symbol');
-setToStringTag(Math, 'Math', true);
-setToStringTag(global.JSON, 'JSON', true);
-
-/***/ }),
-/* 129 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-exports.f = __w_pdfjs_require__(33);
-
-/***/ }),
-/* 130 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var global = __w_pdfjs_require__(8);
-
-var core = __w_pdfjs_require__(9);
-
-var LIBRARY = __w_pdfjs_require__(25);
-
-var wksExt = __w_pdfjs_require__(129);
-
-var defineProperty = __w_pdfjs_require__(11).f;
-
-module.exports = function (name) {
-  var $Symbol = core.Symbol || (core.Symbol = LIBRARY ? {} : global.Symbol || {});
-  if (name.charAt(0) != '_' && !(name in $Symbol)) defineProperty($Symbol, name, {
-    value: wksExt.f(name)
-  });
-};
-
-/***/ }),
-/* 131 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var getKeys = __w_pdfjs_require__(55);
-
-var gOPS = __w_pdfjs_require__(73);
-
-var pIE = __w_pdfjs_require__(74);
-
-module.exports = function (it) {
-  var result = getKeys(it);
-  var getSymbols = gOPS.f;
-
-  if (getSymbols) {
-    var symbols = getSymbols(it);
-    var isEnum = pIE.f;
-    var i = 0;
-    var key;
-
-    while (symbols.length > i) {
-      if (isEnum.call(it, key = symbols[i++])) result.push(key);
-    }
-  }
-
-  return result;
-};
-
-/***/ }),
-/* 132 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-var toIObject = __w_pdfjs_require__(43);
-
-var gOPN = __w_pdfjs_require__(133).f;
-
-var toString = {}.toString;
-var windowNames = (typeof window === "undefined" ? "undefined" : _typeof(window)) == 'object' && window && Object.getOwnPropertyNames ? Object.getOwnPropertyNames(window) : [];
-
-var getWindowNames = function getWindowNames(it) {
-  try {
-    return gOPN(it);
-  } catch (e) {
-    return windowNames.slice();
-  }
-};
-
-module.exports.f = function getOwnPropertyNames(it) {
-  return windowNames && toString.call(it) == '[object Window]' ? getWindowNames(it) : gOPN(toIObject(it));
-};
-
-/***/ }),
-/* 133 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $keys = __w_pdfjs_require__(56);
-
-var hiddenKeys = __w_pdfjs_require__(58).concat('length', 'prototype');
-
-exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
-  return $keys(O, hiddenKeys);
-};
-
-/***/ }),
-/* 134 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(135);
-
-module.exports = __w_pdfjs_require__(9).String.padStart;
-
-/***/ }),
-/* 135 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $export = __w_pdfjs_require__(7);
-
-var $pad = __w_pdfjs_require__(136);
-
-var userAgent = __w_pdfjs_require__(96);
-
-var WEBKIT_BUG = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(userAgent);
-$export($export.P + $export.F * WEBKIT_BUG, 'String', {
-  padStart: function padStart(maxLength) {
-    return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, true);
-  }
-});
-
-/***/ }),
-/* 136 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var toLength = __w_pdfjs_require__(28);
-
-var repeat = __w_pdfjs_require__(137);
-
-var defined = __w_pdfjs_require__(34);
-
-module.exports = function (that, maxLength, fillString, left) {
-  var S = String(defined(that));
-  var stringLength = S.length;
-  var fillStr = fillString === undefined ? ' ' : String(fillString);
-  var intMaxLength = toLength(maxLength);
-  if (intMaxLength <= stringLength || fillStr == '') return S;
-  var fillLen = intMaxLength - stringLength;
-  var stringFiller = repeat.call(fillStr, Math.ceil(fillLen / fillStr.length));
-  if (stringFiller.length > fillLen) stringFiller = stringFiller.slice(0, fillLen);
-  return left ? stringFiller + S : S + stringFiller;
-};
-
-/***/ }),
-/* 137 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var toInteger = __w_pdfjs_require__(29);
-
-var defined = __w_pdfjs_require__(34);
-
-module.exports = function repeat(count) {
-  var str = String(defined(this));
-  var res = '';
-  var n = toInteger(count);
-  if (n < 0 || n == Infinity) throw RangeError("Count can't be negative");
-
-  for (; n > 0; (n >>>= 1) && (str += str)) {
-    if (n & 1) res += str;
-  }
-
-  return res;
-};
-
-/***/ }),
-/* 138 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(139);
-
-module.exports = __w_pdfjs_require__(9).String.padEnd;
-
-/***/ }),
-/* 139 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $export = __w_pdfjs_require__(7);
-
-var $pad = __w_pdfjs_require__(136);
-
-var userAgent = __w_pdfjs_require__(96);
-
-var WEBKIT_BUG = /Version\/10\.\d+(\.\d+)?( Mobile\/\w+)? Safari\//.test(userAgent);
-$export($export.P + $export.F * WEBKIT_BUG, 'String', {
-  padEnd: function padEnd(maxLength) {
-    return $pad(this, maxLength, arguments.length > 1 ? arguments[1] : undefined, false);
-  }
-});
-
-/***/ }),
-/* 140 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-__w_pdfjs_require__(141);
-
-module.exports = __w_pdfjs_require__(9).Object.values;
-
-/***/ }),
-/* 141 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var $export = __w_pdfjs_require__(7);
-
-var $values = __w_pdfjs_require__(142)(false);
-
-$export($export.S, 'Object', {
-  values: function values(it) {
-    return $values(it);
-  }
-});
-
-/***/ }),
-/* 142 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var DESCRIPTORS = __w_pdfjs_require__(15);
-
-var getKeys = __w_pdfjs_require__(55);
-
-var toIObject = __w_pdfjs_require__(43);
-
-var isEnum = __w_pdfjs_require__(74).f;
-
-module.exports = function (isEntries) {
-  return function (it) {
-    var O = toIObject(it);
-    var keys = getKeys(O);
-    var length = keys.length;
-    var i = 0;
-    var result = [];
-    var key;
-
-    while (length > i) {
-      key = keys[i++];
-
-      if (!DESCRIPTORS || isEnum.call(O, key)) {
-        result.push(isEntries ? [key, O[key]] : O[key]);
-      }
-    }
-
-    return result;
-  };
-};
-
-/***/ }),
-/* 143 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-{
-  var isReadableStreamSupported = false;
-
-  if (typeof ReadableStream !== 'undefined') {
-    try {
-      new ReadableStream({
-        start: function start(controller) {
-          controller.close();
-        }
-      });
-      isReadableStreamSupported = true;
-    } catch (e) {}
-  }
-
-  if (isReadableStreamSupported) {
-    exports.ReadableStream = ReadableStream;
-  } else {
-    exports.ReadableStream = __w_pdfjs_require__(144).ReadableStream;
-  }
-}
-
-/***/ }),
-/* 144 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-function _typeof2(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof2 = function _typeof2(obj) { return typeof obj; }; } else { _typeof2 = function _typeof2(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof2(obj); }
-
-(function (e, a) {
-  for (var i in a) {
-    e[i] = a[i];
-  }
-})(exports, function (modules) {
-  var installedModules = {};
-
-  function __w_pdfjs_require__(moduleId) {
-    if (installedModules[moduleId]) return installedModules[moduleId].exports;
-    var module = installedModules[moduleId] = {
-      i: moduleId,
-      l: false,
-      exports: {}
-    };
-    modules[moduleId].call(module.exports, module, module.exports, __w_pdfjs_require__);
-    module.l = true;
-    return module.exports;
-  }
-
-  __w_pdfjs_require__.m = modules;
-  __w_pdfjs_require__.c = installedModules;
-
-  __w_pdfjs_require__.i = function (value) {
-    return value;
-  };
-
-  __w_pdfjs_require__.d = function (exports, name, getter) {
-    if (!__w_pdfjs_require__.o(exports, name)) {
-      Object.defineProperty(exports, name, {
-        configurable: false,
-        enumerable: true,
-        get: getter
-      });
-    }
-  };
-
-  __w_pdfjs_require__.n = function (module) {
-    var getter = module && module.__esModule ? function getDefault() {
-      return module['default'];
-    } : function getModuleExports() {
-      return module;
-    };
-
-    __w_pdfjs_require__.d(getter, 'a', getter);
-
-    return getter;
-  };
-
-  __w_pdfjs_require__.o = function (object, property) {
-    return Object.prototype.hasOwnProperty.call(object, property);
-  };
-
-  __w_pdfjs_require__.p = "";
-  return __w_pdfjs_require__(__w_pdfjs_require__.s = 7);
-}([function (module, exports, __w_pdfjs_require__) {
-  "use strict";
-
-  var _typeof = typeof Symbol === "function" && _typeof2(Symbol.iterator) === "symbol" ? function (obj) {
-    return _typeof2(obj);
-  } : function (obj) {
-    return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : _typeof2(obj);
-  };
-
-  var _require = __w_pdfjs_require__(1),
-      assert = _require.assert;
-
-  function IsPropertyKey(argument) {
-    return typeof argument === 'string' || (typeof argument === 'undefined' ? 'undefined' : _typeof(argument)) === 'symbol';
-  }
-
-  exports.typeIsObject = function (x) {
-    return (typeof x === 'undefined' ? 'undefined' : _typeof(x)) === 'object' && x !== null || typeof x === 'function';
-  };
-
-  exports.createDataProperty = function (o, p, v) {
-    assert(exports.typeIsObject(o));
-    Object.defineProperty(o, p, {
-      value: v,
-      writable: true,
-      enumerable: true,
-      configurable: true
-    });
-  };
-
-  exports.createArrayFromList = function (elements) {
-    return elements.slice();
-  };
-
-  exports.ArrayBufferCopy = function (dest, destOffset, src, srcOffset, n) {
-    new Uint8Array(dest).set(new Uint8Array(src, srcOffset, n), destOffset);
-  };
-
-  exports.CreateIterResultObject = function (value, done) {
-    assert(typeof done === 'boolean');
-    var obj = {};
-    Object.defineProperty(obj, 'value', {
-      value: value,
-      enumerable: true,
-      writable: true,
-      configurable: true
-    });
-    Object.defineProperty(obj, 'done', {
-      value: done,
-      enumerable: true,
-      writable: true,
-      configurable: true
-    });
-    return obj;
-  };
-
-  exports.IsFiniteNonNegativeNumber = function (v) {
-    if (Number.isNaN(v)) {
-      return false;
-    }
-
-    if (v === Infinity) {
-      return false;
-    }
-
-    if (v < 0) {
-      return false;
-    }
-
-    return true;
-  };
-
-  function Call(F, V, args) {
-    if (typeof F !== 'function') {
-      throw new TypeError('Argument is not a function');
-    }
-
-    return Function.prototype.apply.call(F, V, args);
-  }
-
-  exports.InvokeOrNoop = function (O, P, args) {
-    assert(O !== undefined);
-    assert(IsPropertyKey(P));
-    assert(Array.isArray(args));
-    var method = O[P];
-
-    if (method === undefined) {
-      return undefined;
-    }
-
-    return Call(method, O, args);
-  };
-
-  exports.PromiseInvokeOrNoop = function (O, P, args) {
-    assert(O !== undefined);
-    assert(IsPropertyKey(P));
-    assert(Array.isArray(args));
-
-    try {
-      return Promise.resolve(exports.InvokeOrNoop(O, P, args));
-    } catch (returnValueE) {
-      return Promise.reject(returnValueE);
-    }
-  };
-
-  exports.PromiseInvokeOrPerformFallback = function (O, P, args, F, argsF) {
-    assert(O !== undefined);
-    assert(IsPropertyKey(P));
-    assert(Array.isArray(args));
-    assert(Array.isArray(argsF));
-    var method = void 0;
-
-    try {
-      method = O[P];
-    } catch (methodE) {
-      return Promise.reject(methodE);
-    }
-
-    if (method === undefined) {
-      return F.apply(null, argsF);
-    }
-
-    try {
-      return Promise.resolve(Call(method, O, args));
-    } catch (e) {
-      return Promise.reject(e);
-    }
-  };
-
-  exports.TransferArrayBuffer = function (O) {
-    return O.slice();
-  };
-
-  exports.ValidateAndNormalizeHighWaterMark = function (highWaterMark) {
-    highWaterMark = Number(highWaterMark);
-
-    if (Number.isNaN(highWaterMark) || highWaterMark < 0) {
-      throw new RangeError('highWaterMark property of a queuing strategy must be non-negative and non-NaN');
-    }
-
-    return highWaterMark;
-  };
-
-  exports.ValidateAndNormalizeQueuingStrategy = function (size, highWaterMark) {
-    if (size !== undefined && typeof size !== 'function') {
-      throw new TypeError('size property of a queuing strategy must be a function');
-    }
-
-    highWaterMark = exports.ValidateAndNormalizeHighWaterMark(highWaterMark);
-    return {
-      size: size,
-      highWaterMark: highWaterMark
-    };
-  };
-}, function (module, exports, __w_pdfjs_require__) {
-  "use strict";
-
-  function rethrowAssertionErrorRejection(e) {
-    if (e && e.constructor === AssertionError) {
-      setTimeout(function () {
-        throw e;
-      }, 0);
-    }
-  }
-
-  function AssertionError(message) {
-    this.name = 'AssertionError';
-    this.message = message || '';
-    this.stack = new Error().stack;
-  }
-
-  AssertionError.prototype = Object.create(Error.prototype);
-  AssertionError.prototype.constructor = AssertionError;
-
-  function assert(value, message) {
-    if (!value) {
-      throw new AssertionError(message);
-    }
-  }
-
-  module.exports = {
-    rethrowAssertionErrorRejection: rethrowAssertionErrorRejection,
-    AssertionError: AssertionError,
-    assert: assert
-  };
-}, function (module, exports, __w_pdfjs_require__) {
-  "use strict";
-
-  var _createClass = function () {
-    function defineProperties(target, props) {
-      for (var i = 0; i < props.length; i++) {
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-      }
-    }
-
-    return function (Constructor, protoProps, staticProps) {
-      if (protoProps) defineProperties(Constructor.prototype, protoProps);
-      if (staticProps) defineProperties(Constructor, staticProps);
-      return Constructor;
-    };
-  }();
-
-  function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-      throw new TypeError("Cannot call a class as a function");
-    }
-  }
-
-  var _require = __w_pdfjs_require__(0),
-      InvokeOrNoop = _require.InvokeOrNoop,
-      PromiseInvokeOrNoop = _require.PromiseInvokeOrNoop,
-      ValidateAndNormalizeQueuingStrategy = _require.ValidateAndNormalizeQueuingStrategy,
-      typeIsObject = _require.typeIsObject;
-
-  var _require2 = __w_pdfjs_require__(1),
-      assert = _require2.assert,
-      rethrowAssertionErrorRejection = _require2.rethrowAssertionErrorRejection;
-
-  var _require3 = __w_pdfjs_require__(3),
-      DequeueValue = _require3.DequeueValue,
-      EnqueueValueWithSize = _require3.EnqueueValueWithSize,
-      PeekQueueValue = _require3.PeekQueueValue,
-      ResetQueue = _require3.ResetQueue;
-
-  var WritableStream = function () {
-    function WritableStream() {
-      var underlyingSink = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
-      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-          size = _ref.size,
-          _ref$highWaterMark = _ref.highWaterMark,
-          highWaterMark = _ref$highWaterMark === undefined ? 1 : _ref$highWaterMark;
-
-      _classCallCheck(this, WritableStream);
-
-      this._state = 'writable';
-      this._storedError = undefined;
-      this._writer = undefined;
-      this._writableStreamController = undefined;
-      this._writeRequests = [];
-      this._inFlightWriteRequest = undefined;
-      this._closeRequest = undefined;
-      this._inFlightCloseRequest = undefined;
-      this._pendingAbortRequest = undefined;
-      this._backpressure = false;
-      var type = underlyingSink.type;
-
-      if (type !== undefined) {
-        throw new RangeError('Invalid type is specified');
-      }
-
-      this._writableStreamController = new WritableStreamDefaultController(this, underlyingSink, size, highWaterMark);
-
-      this._writableStreamController.__startSteps();
-    }
-
-    _createClass(WritableStream, [{
-      key: 'abort',
-      value: function abort(reason) {
-        if (IsWritableStream(this) === false) {
-          return Promise.reject(streamBrandCheckException('abort'));
-        }
-
-        if (IsWritableStreamLocked(this) === true) {
-          return Promise.reject(new TypeError('Cannot abort a stream that already has a writer'));
-        }
-
-        return WritableStreamAbort(this, reason);
-      }
-    }, {
-      key: 'getWriter',
-      value: function getWriter() {
-        if (IsWritableStream(this) === false) {
-          throw streamBrandCheckException('getWriter');
-        }
-
-        return AcquireWritableStreamDefaultWriter(this);
-      }
-    }, {
-      key: 'locked',
-      get: function get() {
-        if (IsWritableStream(this) === false) {
-          throw streamBrandCheckException('locked');
-        }
-
-        return IsWritableStreamLocked(this);
-      }
-    }]);
-
-    return WritableStream;
-  }();
-
-  module.exports = {
-    AcquireWritableStreamDefaultWriter: AcquireWritableStreamDefaultWriter,
-    IsWritableStream: IsWritableStream,
-    IsWritableStreamLocked: IsWritableStreamLocked,
-    WritableStream: WritableStream,
-    WritableStreamAbort: WritableStreamAbort,
-    WritableStreamDefaultControllerError: WritableStreamDefaultControllerError,
-    WritableStreamDefaultWriterCloseWithErrorPropagation: WritableStreamDefaultWriterCloseWithErrorPropagation,
-    WritableStreamDefaultWriterRelease: WritableStreamDefaultWriterRelease,
-    WritableStreamDefaultWriterWrite: WritableStreamDefaultWriterWrite,
-    WritableStreamCloseQueuedOrInFlight: WritableStreamCloseQueuedOrInFlight
-  };
-
-  function AcquireWritableStreamDefaultWriter(stream) {
-    return new WritableStreamDefaultWriter(stream);
-  }
-
-  function IsWritableStream(x) {
-    if (!typeIsObject(x)) {
-      return false;
-    }
-
-    if (!Object.prototype.hasOwnProperty.call(x, '_writableStreamController')) {
-      return false;
-    }
-
-    return true;
-  }
-
-  function IsWritableStreamLocked(stream) {
-    assert(IsWritableStream(stream) === true, 'IsWritableStreamLocked should only be used on known writable streams');
-
-    if (stream._writer === undefined) {
-      return false;
-    }
-
-    return true;
-  }
-
-  function WritableStreamAbort(stream, reason) {
-    var state = stream._state;
-
-    if (state === 'closed') {
-      return Promise.resolve(undefined);
-    }
-
-    if (state === 'errored') {
-      return Promise.reject(stream._storedError);
-    }
-
-    var error = new TypeError('Requested to abort');
-
-    if (stream._pendingAbortRequest !== undefined) {
-      return Promise.reject(error);
-    }
-
-    assert(state === 'writable' || state === 'erroring', 'state must be writable or erroring');
-    var wasAlreadyErroring = false;
-
-    if (state === 'erroring') {
-      wasAlreadyErroring = true;
-      reason = undefined;
-    }
-
-    var promise = new Promise(function (resolve, reject) {
-      stream._pendingAbortRequest = {
-        _resolve: resolve,
-        _reject: reject,
-        _reason: reason,
-        _wasAlreadyErroring: wasAlreadyErroring
-      };
-    });
-
-    if (wasAlreadyErroring === false) {
-      WritableStreamStartErroring(stream, error);
-    }
-
-    return promise;
-  }
-
-  function WritableStreamAddWriteRequest(stream) {
-    assert(IsWritableStreamLocked(stream) === true);
-    assert(stream._state === 'writable');
-    var promise = new Promise(function (resolve, reject) {
-      var writeRequest = {
-        _resolve: resolve,
-        _reject: reject
-      };
-
-      stream._writeRequests.push(writeRequest);
-    });
-    return promise;
-  }
-
-  function WritableStreamDealWithRejection(stream, error) {
-    var state = stream._state;
-
-    if (state === 'writable') {
-      WritableStreamStartErroring(stream, error);
-      return;
-    }
-
-    assert(state === 'erroring');
-    WritableStreamFinishErroring(stream);
-  }
-
-  function WritableStreamStartErroring(stream, reason) {
-    assert(stream._storedError === undefined, 'stream._storedError === undefined');
-    assert(stream._state === 'writable', 'state must be writable');
-    var controller = stream._writableStreamController;
-    assert(controller !== undefined, 'controller must not be undefined');
-    stream._state = 'erroring';
-    stream._storedError = reason;
-    var writer = stream._writer;
-
-    if (writer !== undefined) {
-      WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, reason);
-    }
-
-    if (WritableStreamHasOperationMarkedInFlight(stream) === false && controller._started === true) {
-      WritableStreamFinishErroring(stream);
-    }
-  }
-
-  function WritableStreamFinishErroring(stream) {
-    assert(stream._state === 'erroring', 'stream._state === erroring');
-    assert(WritableStreamHasOperationMarkedInFlight(stream) === false, 'WritableStreamHasOperationMarkedInFlight(stream) === false');
-    stream._state = 'errored';
-
-    stream._writableStreamController.__errorSteps();
-
-    var storedError = stream._storedError;
-
-    for (var i = 0; i < stream._writeRequests.length; i++) {
-      var writeRequest = stream._writeRequests[i];
-
-      writeRequest._reject(storedError);
-    }
-
-    stream._writeRequests = [];
-
-    if (stream._pendingAbortRequest === undefined) {
-      WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
-      return;
-    }
-
-    var abortRequest = stream._pendingAbortRequest;
-    stream._pendingAbortRequest = undefined;
-
-    if (abortRequest._wasAlreadyErroring === true) {
-      abortRequest._reject(storedError);
-
-      WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
-      return;
-    }
-
-    var promise = stream._writableStreamController.__abortSteps(abortRequest._reason);
-
-    promise.then(function () {
-      abortRequest._resolve();
-
-      WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
-    }, function (reason) {
-      abortRequest._reject(reason);
-
-      WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream);
-    });
-  }
-
-  function WritableStreamFinishInFlightWrite(stream) {
-    assert(stream._inFlightWriteRequest !== undefined);
-
-    stream._inFlightWriteRequest._resolve(undefined);
-
-    stream._inFlightWriteRequest = undefined;
-  }
-
-  function WritableStreamFinishInFlightWriteWithError(stream, error) {
-    assert(stream._inFlightWriteRequest !== undefined);
-
-    stream._inFlightWriteRequest._reject(error);
-
-    stream._inFlightWriteRequest = undefined;
-    assert(stream._state === 'writable' || stream._state === 'erroring');
-    WritableStreamDealWithRejection(stream, error);
-  }
-
-  function WritableStreamFinishInFlightClose(stream) {
-    assert(stream._inFlightCloseRequest !== undefined);
-
-    stream._inFlightCloseRequest._resolve(undefined);
-
-    stream._inFlightCloseRequest = undefined;
-    var state = stream._state;
-    assert(state === 'writable' || state === 'erroring');
-
-    if (state === 'erroring') {
-      stream._storedError = undefined;
-
-      if (stream._pendingAbortRequest !== undefined) {
-        stream._pendingAbortRequest._resolve();
-
-        stream._pendingAbortRequest = undefined;
-      }
-    }
-
-    stream._state = 'closed';
-    var writer = stream._writer;
-
-    if (writer !== undefined) {
-      defaultWriterClosedPromiseResolve(writer);
-    }
-
-    assert(stream._pendingAbortRequest === undefined, 'stream._pendingAbortRequest === undefined');
-    assert(stream._storedError === undefined, 'stream._storedError === undefined');
-  }
-
-  function WritableStreamFinishInFlightCloseWithError(stream, error) {
-    assert(stream._inFlightCloseRequest !== undefined);
-
-    stream._inFlightCloseRequest._reject(error);
-
-    stream._inFlightCloseRequest = undefined;
-    assert(stream._state === 'writable' || stream._state === 'erroring');
-
-    if (stream._pendingAbortRequest !== undefined) {
-      stream._pendingAbortRequest._reject(error);
-
-      stream._pendingAbortRequest = undefined;
-    }
-
-    WritableStreamDealWithRejection(stream, error);
-  }
-
-  function WritableStreamCloseQueuedOrInFlight(stream) {
-    if (stream._closeRequest === undefined && stream._inFlightCloseRequest === undefined) {
-      return false;
-    }
-
-    return true;
-  }
-
-  function WritableStreamHasOperationMarkedInFlight(stream) {
-    if (stream._inFlightWriteRequest === undefined && stream._inFlightCloseRequest === undefined) {
-      return false;
-    }
-
-    return true;
-  }
-
-  function WritableStreamMarkCloseRequestInFlight(stream) {
-    assert(stream._inFlightCloseRequest === undefined);
-    assert(stream._closeRequest !== undefined);
-    stream._inFlightCloseRequest = stream._closeRequest;
-    stream._closeRequest = undefined;
-  }
-
-  function WritableStreamMarkFirstWriteRequestInFlight(stream) {
-    assert(stream._inFlightWriteRequest === undefined, 'there must be no pending write request');
-    assert(stream._writeRequests.length !== 0, 'writeRequests must not be empty');
-    stream._inFlightWriteRequest = stream._writeRequests.shift();
-  }
-
-  function WritableStreamRejectCloseAndClosedPromiseIfNeeded(stream) {
-    assert(stream._state === 'errored', '_stream_.[[state]] is `"errored"`');
-
-    if (stream._closeRequest !== undefined) {
-      assert(stream._inFlightCloseRequest === undefined);
-
-      stream._closeRequest._reject(stream._storedError);
-
-      stream._closeRequest = undefined;
-    }
-
-    var writer = stream._writer;
-
-    if (writer !== undefined) {
-      defaultWriterClosedPromiseReject(writer, stream._storedError);
-
-      writer._closedPromise["catch"](function () {});
-    }
-  }
-
-  function WritableStreamUpdateBackpressure(stream, backpressure) {
-    assert(stream._state === 'writable');
-    assert(WritableStreamCloseQueuedOrInFlight(stream) === false);
-    var writer = stream._writer;
-
-    if (writer !== undefined && backpressure !== stream._backpressure) {
-      if (backpressure === true) {
-        defaultWriterReadyPromiseReset(writer);
-      } else {
-        assert(backpressure === false);
-        defaultWriterReadyPromiseResolve(writer);
-      }
-    }
-
-    stream._backpressure = backpressure;
-  }
-
-  var WritableStreamDefaultWriter = function () {
-    function WritableStreamDefaultWriter(stream) {
-      _classCallCheck(this, WritableStreamDefaultWriter);
-
-      if (IsWritableStream(stream) === false) {
-        throw new TypeError('WritableStreamDefaultWriter can only be constructed with a WritableStream instance');
-      }
-
-      if (IsWritableStreamLocked(stream) === true) {
-        throw new TypeError('This stream has already been locked for exclusive writing by another writer');
-      }
-
-      this._ownerWritableStream = stream;
-      stream._writer = this;
-      var state = stream._state;
-
-      if (state === 'writable') {
-        if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._backpressure === true) {
-          defaultWriterReadyPromiseInitialize(this);
-        } else {
-          defaultWriterReadyPromiseInitializeAsResolved(this);
-        }
-
-        defaultWriterClosedPromiseInitialize(this);
-      } else if (state === 'erroring') {
-        defaultWriterReadyPromiseInitializeAsRejected(this, stream._storedError);
-
-        this._readyPromise["catch"](function () {});
-
-        defaultWriterClosedPromiseInitialize(this);
-      } else if (state === 'closed') {
-        defaultWriterReadyPromiseInitializeAsResolved(this);
-        defaultWriterClosedPromiseInitializeAsResolved(this);
-      } else {
-        assert(state === 'errored', 'state must be errored');
-        var storedError = stream._storedError;
-        defaultWriterReadyPromiseInitializeAsRejected(this, storedError);
-
-        this._readyPromise["catch"](function () {});
-
-        defaultWriterClosedPromiseInitializeAsRejected(this, storedError);
-
-        this._closedPromise["catch"](function () {});
-      }
-    }
-
-    _createClass(WritableStreamDefaultWriter, [{
-      key: 'abort',
-      value: function abort(reason) {
-        if (IsWritableStreamDefaultWriter(this) === false) {
-          return Promise.reject(defaultWriterBrandCheckException('abort'));
-        }
-
-        if (this._ownerWritableStream === undefined) {
-          return Promise.reject(defaultWriterLockException('abort'));
-        }
-
-        return WritableStreamDefaultWriterAbort(this, reason);
-      }
-    }, {
-      key: 'close',
-      value: function close() {
-        if (IsWritableStreamDefaultWriter(this) === false) {
-          return Promise.reject(defaultWriterBrandCheckException('close'));
-        }
-
-        var stream = this._ownerWritableStream;
-
-        if (stream === undefined) {
-          return Promise.reject(defaultWriterLockException('close'));
-        }
-
-        if (WritableStreamCloseQueuedOrInFlight(stream) === true) {
-          return Promise.reject(new TypeError('cannot close an already-closing stream'));
-        }
-
-        return WritableStreamDefaultWriterClose(this);
-      }
-    }, {
-      key: 'releaseLock',
-      value: function releaseLock() {
-        if (IsWritableStreamDefaultWriter(this) === false) {
-          throw defaultWriterBrandCheckException('releaseLock');
-        }
-
-        var stream = this._ownerWritableStream;
-
-        if (stream === undefined) {
-          return;
-        }
-
-        assert(stream._writer !== undefined);
-        WritableStreamDefaultWriterRelease(this);
-      }
-    }, {
-      key: 'write',
-      value: function write(chunk) {
-        if (IsWritableStreamDefaultWriter(this) === false) {
-          return Promise.reject(defaultWriterBrandCheckException('write'));
-        }
-
-        if (this._ownerWritableStream === undefined) {
-          return Promise.reject(defaultWriterLockException('write to'));
-        }
-
-        return WritableStreamDefaultWriterWrite(this, chunk);
-      }
-    }, {
-      key: 'closed',
-      get: function get() {
-        if (IsWritableStreamDefaultWriter(this) === false) {
-          return Promise.reject(defaultWriterBrandCheckException('closed'));
-        }
-
-        return this._closedPromise;
-      }
-    }, {
-      key: 'desiredSize',
-      get: function get() {
-        if (IsWritableStreamDefaultWriter(this) === false) {
-          throw defaultWriterBrandCheckException('desiredSize');
-        }
-
-        if (this._ownerWritableStream === undefined) {
-          throw defaultWriterLockException('desiredSize');
-        }
-
-        return WritableStreamDefaultWriterGetDesiredSize(this);
-      }
-    }, {
-      key: 'ready',
-      get: function get() {
-        if (IsWritableStreamDefaultWriter(this) === false) {
-          return Promise.reject(defaultWriterBrandCheckException('ready'));
-        }
-
-        return this._readyPromise;
-      }
-    }]);
-
-    return WritableStreamDefaultWriter;
-  }();
-
-  function IsWritableStreamDefaultWriter(x) {
-    if (!typeIsObject(x)) {
-      return false;
-    }
-
-    if (!Object.prototype.hasOwnProperty.call(x, '_ownerWritableStream')) {
-      return false;
-    }
-
-    return true;
-  }
-
-  function WritableStreamDefaultWriterAbort(writer, reason) {
-    var stream = writer._ownerWritableStream;
-    assert(stream !== undefined);
-    return WritableStreamAbort(stream, reason);
-  }
-
-  function WritableStreamDefaultWriterClose(writer) {
-    var stream = writer._ownerWritableStream;
-    assert(stream !== undefined);
-    var state = stream._state;
-
-    if (state === 'closed' || state === 'errored') {
-      return Promise.reject(new TypeError('The stream (in ' + state + ' state) is not in the writable state and cannot be closed'));
-    }
-
-    assert(state === 'writable' || state === 'erroring');
-    assert(WritableStreamCloseQueuedOrInFlight(stream) === false);
-    var promise = new Promise(function (resolve, reject) {
-      var closeRequest = {
-        _resolve: resolve,
-        _reject: reject
-      };
-      stream._closeRequest = closeRequest;
-    });
-
-    if (stream._backpressure === true && state === 'writable') {
-      defaultWriterReadyPromiseResolve(writer);
-    }
-
-    WritableStreamDefaultControllerClose(stream._writableStreamController);
-    return promise;
-  }
-
-  function WritableStreamDefaultWriterCloseWithErrorPropagation(writer) {
-    var stream = writer._ownerWritableStream;
-    assert(stream !== undefined);
-    var state = stream._state;
-
-    if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {
-      return Promise.resolve();
-    }
-
-    if (state === 'errored') {
-      return Promise.reject(stream._storedError);
-    }
-
-    assert(state === 'writable' || state === 'erroring');
-    return WritableStreamDefaultWriterClose(writer);
-  }
-
-  function WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, error) {
-    if (writer._closedPromiseState === 'pending') {
-      defaultWriterClosedPromiseReject(writer, error);
-    } else {
-      defaultWriterClosedPromiseResetToRejected(writer, error);
-    }
-
-    writer._closedPromise["catch"](function () {});
-  }
-
-  function WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, error) {
-    if (writer._readyPromiseState === 'pending') {
-      defaultWriterReadyPromiseReject(writer, error);
-    } else {
-      defaultWriterReadyPromiseResetToRejected(writer, error);
-    }
-
-    writer._readyPromise["catch"](function () {});
-  }
-
-  function WritableStreamDefaultWriterGetDesiredSize(writer) {
-    var stream = writer._ownerWritableStream;
-    var state = stream._state;
-
-    if (state === 'errored' || state === 'erroring') {
-      return null;
-    }
-
-    if (state === 'closed') {
-      return 0;
-    }
-
-    return WritableStreamDefaultControllerGetDesiredSize(stream._writableStreamController);
-  }
-
-  function WritableStreamDefaultWriterRelease(writer) {
-    var stream = writer._ownerWritableStream;
-    assert(stream !== undefined);
-    assert(stream._writer === writer);
-    var releasedError = new TypeError('Writer was released and can no longer be used to monitor the stream\'s closedness');
-    WritableStreamDefaultWriterEnsureReadyPromiseRejected(writer, releasedError);
-    WritableStreamDefaultWriterEnsureClosedPromiseRejected(writer, releasedError);
-    stream._writer = undefined;
-    writer._ownerWritableStream = undefined;
-  }
-
-  function WritableStreamDefaultWriterWrite(writer, chunk) {
-    var stream = writer._ownerWritableStream;
-    assert(stream !== undefined);
-    var controller = stream._writableStreamController;
-    var chunkSize = WritableStreamDefaultControllerGetChunkSize(controller, chunk);
-
-    if (stream !== writer._ownerWritableStream) {
-      return Promise.reject(defaultWriterLockException('write to'));
-    }
-
-    var state = stream._state;
-
-    if (state === 'errored') {
-      return Promise.reject(stream._storedError);
-    }
-
-    if (WritableStreamCloseQueuedOrInFlight(stream) === true || state === 'closed') {
-      return Promise.reject(new TypeError('The stream is closing or closed and cannot be written to'));
-    }
-
-    if (state === 'erroring') {
-      return Promise.reject(stream._storedError);
-    }
-
-    assert(state === 'writable');
-    var promise = WritableStreamAddWriteRequest(stream);
-    WritableStreamDefaultControllerWrite(controller, chunk, chunkSize);
-    return promise;
-  }
-
-  var WritableStreamDefaultController = function () {
-    function WritableStreamDefaultController(stream, underlyingSink, size, highWaterMark) {
-      _classCallCheck(this, WritableStreamDefaultController);
-
-      if (IsWritableStream(stream) === false) {
-        throw new TypeError('WritableStreamDefaultController can only be constructed with a WritableStream instance');
-      }
-
-      if (stream._writableStreamController !== undefined) {
-        throw new TypeError('WritableStreamDefaultController instances can only be created by the WritableStream constructor');
-      }
-
-      this._controlledWritableStream = stream;
-      this._underlyingSink = underlyingSink;
-      this._queue = undefined;
-      this._queueTotalSize = undefined;
-      ResetQueue(this);
-      this._started = false;
-      var normalizedStrategy = ValidateAndNormalizeQueuingStrategy(size, highWaterMark);
-      this._strategySize = normalizedStrategy.size;
-      this._strategyHWM = normalizedStrategy.highWaterMark;
-      var backpressure = WritableStreamDefaultControllerGetBackpressure(this);
-      WritableStreamUpdateBackpressure(stream, backpressure);
-    }
-
-    _createClass(WritableStreamDefaultController, [{
-      key: 'error',
-      value: function error(e) {
-        if (IsWritableStreamDefaultController(this) === false) {
-          throw new TypeError('WritableStreamDefaultController.prototype.error can only be used on a WritableStreamDefaultController');
-        }
-
-        var state = this._controlledWritableStream._state;
-
-        if (state !== 'writable') {
-          return;
-        }
-
-        WritableStreamDefaultControllerError(this, e);
-      }
-    }, {
-      key: '__abortSteps',
-      value: function __abortSteps(reason) {
-        return PromiseInvokeOrNoop(this._underlyingSink, 'abort', [reason]);
-      }
-    }, {
-      key: '__errorSteps',
-      value: function __errorSteps() {
-        ResetQueue(this);
-      }
-    }, {
-      key: '__startSteps',
-      value: function __startSteps() {
-        var _this = this;
-
-        var startResult = InvokeOrNoop(this._underlyingSink, 'start', [this]);
-        var stream = this._controlledWritableStream;
-        Promise.resolve(startResult).then(function () {
-          assert(stream._state === 'writable' || stream._state === 'erroring');
-          _this._started = true;
-          WritableStreamDefaultControllerAdvanceQueueIfNeeded(_this);
-        }, function (r) {
-          assert(stream._state === 'writable' || stream._state === 'erroring');
-          _this._started = true;
-          WritableStreamDealWithRejection(stream, r);
-        })["catch"](rethrowAssertionErrorRejection);
-      }
-    }]);
-
-    return WritableStreamDefaultController;
-  }();
-
-  function WritableStreamDefaultControllerClose(controller) {
-    EnqueueValueWithSize(controller, 'close', 0);
-    WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
-  }
-
-  function WritableStreamDefaultControllerGetChunkSize(controller, chunk) {
-    var strategySize = controller._strategySize;
-
-    if (strategySize === undefined) {
-      return 1;
-    }
-
-    try {
-      return strategySize(chunk);
-    } catch (chunkSizeE) {
-      WritableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);
-      return 1;
-    }
-  }
-
-  function WritableStreamDefaultControllerGetDesiredSize(controller) {
-    return controller._strategyHWM - controller._queueTotalSize;
-  }
-
-  function WritableStreamDefaultControllerWrite(controller, chunk, chunkSize) {
-    var writeRecord = {
-      chunk: chunk
-    };
-
-    try {
-      EnqueueValueWithSize(controller, writeRecord, chunkSize);
-    } catch (enqueueE) {
-      WritableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);
-      return;
-    }
-
-    var stream = controller._controlledWritableStream;
-
-    if (WritableStreamCloseQueuedOrInFlight(stream) === false && stream._state === 'writable') {
-      var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
-      WritableStreamUpdateBackpressure(stream, backpressure);
-    }
-
-    WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
-  }
-
-  function IsWritableStreamDefaultController(x) {
-    if (!typeIsObject(x)) {
-      return false;
-    }
-
-    if (!Object.prototype.hasOwnProperty.call(x, '_underlyingSink')) {
-      return false;
-    }
-
-    return true;
-  }
-
-  function WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller) {
-    var stream = controller._controlledWritableStream;
-
-    if (controller._started === false) {
-      return;
-    }
-
-    if (stream._inFlightWriteRequest !== undefined) {
-      return;
-    }
-
-    var state = stream._state;
-
-    if (state === 'closed' || state === 'errored') {
-      return;
-    }
-
-    if (state === 'erroring') {
-      WritableStreamFinishErroring(stream);
-      return;
-    }
-
-    if (controller._queue.length === 0) {
-      return;
-    }
-
-    var writeRecord = PeekQueueValue(controller);
-
-    if (writeRecord === 'close') {
-      WritableStreamDefaultControllerProcessClose(controller);
-    } else {
-      WritableStreamDefaultControllerProcessWrite(controller, writeRecord.chunk);
-    }
-  }
-
-  function WritableStreamDefaultControllerErrorIfNeeded(controller, error) {
-    if (controller._controlledWritableStream._state === 'writable') {
-      WritableStreamDefaultControllerError(controller, error);
-    }
-  }
-
-  function WritableStreamDefaultControllerProcessClose(controller) {
-    var stream = controller._controlledWritableStream;
-    WritableStreamMarkCloseRequestInFlight(stream);
-    DequeueValue(controller);
-    assert(controller._queue.length === 0, 'queue must be empty once the final write record is dequeued');
-    var sinkClosePromise = PromiseInvokeOrNoop(controller._underlyingSink, 'close', []);
-    sinkClosePromise.then(function () {
-      WritableStreamFinishInFlightClose(stream);
-    }, function (reason) {
-      WritableStreamFinishInFlightCloseWithError(stream, reason);
-    })["catch"](rethrowAssertionErrorRejection);
-  }
-
-  function WritableStreamDefaultControllerProcessWrite(controller, chunk) {
-    var stream = controller._controlledWritableStream;
-    WritableStreamMarkFirstWriteRequestInFlight(stream);
-    var sinkWritePromise = PromiseInvokeOrNoop(controller._underlyingSink, 'write', [chunk, controller]);
-    sinkWritePromise.then(function () {
-      WritableStreamFinishInFlightWrite(stream);
-      var state = stream._state;
-      assert(state === 'writable' || state === 'erroring');
-      DequeueValue(controller);
-
-      if (WritableStreamCloseQueuedOrInFlight(stream) === false && state === 'writable') {
-        var backpressure = WritableStreamDefaultControllerGetBackpressure(controller);
-        WritableStreamUpdateBackpressure(stream, backpressure);
-      }
-
-      WritableStreamDefaultControllerAdvanceQueueIfNeeded(controller);
-    }, function (reason) {
-      WritableStreamFinishInFlightWriteWithError(stream, reason);
-    })["catch"](rethrowAssertionErrorRejection);
-  }
-
-  function WritableStreamDefaultControllerGetBackpressure(controller) {
-    var desiredSize = WritableStreamDefaultControllerGetDesiredSize(controller);
-    return desiredSize <= 0;
-  }
-
-  function WritableStreamDefaultControllerError(controller, error) {
-    var stream = controller._controlledWritableStream;
-    assert(stream._state === 'writable');
-    WritableStreamStartErroring(stream, error);
-  }
-
-  function streamBrandCheckException(name) {
-    return new TypeError('WritableStream.prototype.' + name + ' can only be used on a WritableStream');
-  }
-
-  function defaultWriterBrandCheckException(name) {
-    return new TypeError('WritableStreamDefaultWriter.prototype.' + name + ' can only be used on a WritableStreamDefaultWriter');
-  }
-
-  function defaultWriterLockException(name) {
-    return new TypeError('Cannot ' + name + ' a stream using a released writer');
-  }
-
-  function defaultWriterClosedPromiseInitialize(writer) {
-    writer._closedPromise = new Promise(function (resolve, reject) {
-      writer._closedPromise_resolve = resolve;
-      writer._closedPromise_reject = reject;
-      writer._closedPromiseState = 'pending';
-    });
-  }
-
-  function defaultWriterClosedPromiseInitializeAsRejected(writer, reason) {
-    writer._closedPromise = Promise.reject(reason);
-    writer._closedPromise_resolve = undefined;
-    writer._closedPromise_reject = undefined;
-    writer._closedPromiseState = 'rejected';
-  }
-
-  function defaultWriterClosedPromiseInitializeAsResolved(writer) {
-    writer._closedPromise = Promise.resolve(undefined);
-    writer._closedPromise_resolve = undefined;
-    writer._closedPromise_reject = undefined;
-    writer._closedPromiseState = 'resolved';
-  }
-
-  function defaultWriterClosedPromiseReject(writer, reason) {
-    assert(writer._closedPromise_resolve !== undefined, 'writer._closedPromise_resolve !== undefined');
-    assert(writer._closedPromise_reject !== undefined, 'writer._closedPromise_reject !== undefined');
-    assert(writer._closedPromiseState === 'pending', 'writer._closedPromiseState is pending');
-
-    writer._closedPromise_reject(reason);
-
-    writer._closedPromise_resolve = undefined;
-    writer._closedPromise_reject = undefined;
-    writer._closedPromiseState = 'rejected';
-  }
-
-  function defaultWriterClosedPromiseResetToRejected(writer, reason) {
-    assert(writer._closedPromise_resolve === undefined, 'writer._closedPromise_resolve === undefined');
-    assert(writer._closedPromise_reject === undefined, 'writer._closedPromise_reject === undefined');
-    assert(writer._closedPromiseState !== 'pending', 'writer._closedPromiseState is not pending');
-    writer._closedPromise = Promise.reject(reason);
-    writer._closedPromiseState = 'rejected';
-  }
-
-  function defaultWriterClosedPromiseResolve(writer) {
-    assert(writer._closedPromise_resolve !== undefined, 'writer._closedPromise_resolve !== undefined');
-    assert(writer._closedPromise_reject !== undefined, 'writer._closedPromise_reject !== undefined');
-    assert(writer._closedPromiseState === 'pending', 'writer._closedPromiseState is pending');
-
-    writer._closedPromise_resolve(undefined);
-
-    writer._closedPromise_resolve = undefined;
-    writer._closedPromise_reject = undefined;
-    writer._closedPromiseState = 'resolved';
-  }
-
-  function defaultWriterReadyPromiseInitialize(writer) {
-    writer._readyPromise = new Promise(function (resolve, reject) {
-      writer._readyPromise_resolve = resolve;
-      writer._readyPromise_reject = reject;
-    });
-    writer._readyPromiseState = 'pending';
-  }
-
-  function defaultWriterReadyPromiseInitializeAsRejected(writer, reason) {
-    writer._readyPromise = Promise.reject(reason);
-    writer._readyPromise_resolve = undefined;
-    writer._readyPromise_reject = undefined;
-    writer._readyPromiseState = 'rejected';
-  }
-
-  function defaultWriterReadyPromiseInitializeAsResolved(writer) {
-    writer._readyPromise = Promise.resolve(undefined);
-    writer._readyPromise_resolve = undefined;
-    writer._readyPromise_reject = undefined;
-    writer._readyPromiseState = 'fulfilled';
-  }
-
-  function defaultWriterReadyPromiseReject(writer, reason) {
-    assert(writer._readyPromise_resolve !== undefined, 'writer._readyPromise_resolve !== undefined');
-    assert(writer._readyPromise_reject !== undefined, 'writer._readyPromise_reject !== undefined');
-
-    writer._readyPromise_reject(reason);
-
-    writer._readyPromise_resolve = undefined;
-    writer._readyPromise_reject = undefined;
-    writer._readyPromiseState = 'rejected';
-  }
-
-  function defaultWriterReadyPromiseReset(writer) {
-    assert(writer._readyPromise_resolve === undefined, 'writer._readyPromise_resolve === undefined');
-    assert(writer._readyPromise_reject === undefined, 'writer._readyPromise_reject === undefined');
-    writer._readyPromise = new Promise(function (resolve, reject) {
-      writer._readyPromise_resolve = resolve;
-      writer._readyPromise_reject = reject;
-    });
-    writer._readyPromiseState = 'pending';
-  }
-
-  function defaultWriterReadyPromiseResetToRejected(writer, reason) {
-    assert(writer._readyPromise_resolve === undefined, 'writer._readyPromise_resolve === undefined');
-    assert(writer._readyPromise_reject === undefined, 'writer._readyPromise_reject === undefined');
-    writer._readyPromise = Promise.reject(reason);
-    writer._readyPromiseState = 'rejected';
-  }
-
-  function defaultWriterReadyPromiseResolve(writer) {
-    assert(writer._readyPromise_resolve !== undefined, 'writer._readyPromise_resolve !== undefined');
-    assert(writer._readyPromise_reject !== undefined, 'writer._readyPromise_reject !== undefined');
-
-    writer._readyPromise_resolve(undefined);
-
-    writer._readyPromise_resolve = undefined;
-    writer._readyPromise_reject = undefined;
-    writer._readyPromiseState = 'fulfilled';
-  }
-}, function (module, exports, __w_pdfjs_require__) {
-  "use strict";
-
-  var _require = __w_pdfjs_require__(0),
-      IsFiniteNonNegativeNumber = _require.IsFiniteNonNegativeNumber;
-
-  var _require2 = __w_pdfjs_require__(1),
-      assert = _require2.assert;
-
-  exports.DequeueValue = function (container) {
-    assert('_queue' in container && '_queueTotalSize' in container, 'Spec-level failure: DequeueValue should only be used on containers with [[queue]] and [[queueTotalSize]].');
-    assert(container._queue.length > 0, 'Spec-level failure: should never dequeue from an empty queue.');
-
-    var pair = container._queue.shift();
-
-    container._queueTotalSize -= pair.size;
-
-    if (container._queueTotalSize < 0) {
-      container._queueTotalSize = 0;
-    }
-
-    return pair.value;
-  };
-
-  exports.EnqueueValueWithSize = function (container, value, size) {
-    assert('_queue' in container && '_queueTotalSize' in container, 'Spec-level failure: EnqueueValueWithSize should only be used on containers with [[queue]] and ' + '[[queueTotalSize]].');
-    size = Number(size);
-
-    if (!IsFiniteNonNegativeNumber(size)) {
-      throw new RangeError('Size must be a finite, non-NaN, non-negative number.');
-    }
-
-    container._queue.push({
-      value: value,
-      size: size
-    });
-
-    container._queueTotalSize += size;
-  };
-
-  exports.PeekQueueValue = function (container) {
-    assert('_queue' in container && '_queueTotalSize' in container, 'Spec-level failure: PeekQueueValue should only be used on containers with [[queue]] and [[queueTotalSize]].');
-    assert(container._queue.length > 0, 'Spec-level failure: should never peek at an empty queue.');
-    var pair = container._queue[0];
-    return pair.value;
-  };
-
-  exports.ResetQueue = function (container) {
-    assert('_queue' in container && '_queueTotalSize' in container, 'Spec-level failure: ResetQueue should only be used on containers with [[queue]] and [[queueTotalSize]].');
-    container._queue = [];
-    container._queueTotalSize = 0;
-  };
-}, function (module, exports, __w_pdfjs_require__) {
-  "use strict";
-
-  var _createClass = function () {
-    function defineProperties(target, props) {
-      for (var i = 0; i < props.length; i++) {
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-      }
-    }
-
-    return function (Constructor, protoProps, staticProps) {
-      if (protoProps) defineProperties(Constructor.prototype, protoProps);
-      if (staticProps) defineProperties(Constructor, staticProps);
-      return Constructor;
-    };
-  }();
-
-  function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-      throw new TypeError("Cannot call a class as a function");
-    }
-  }
-
-  var _require = __w_pdfjs_require__(0),
-      ArrayBufferCopy = _require.ArrayBufferCopy,
-      CreateIterResultObject = _require.CreateIterResultObject,
-      IsFiniteNonNegativeNumber = _require.IsFiniteNonNegativeNumber,
-      InvokeOrNoop = _require.InvokeOrNoop,
-      PromiseInvokeOrNoop = _require.PromiseInvokeOrNoop,
-      TransferArrayBuffer = _require.TransferArrayBuffer,
-      ValidateAndNormalizeQueuingStrategy = _require.ValidateAndNormalizeQueuingStrategy,
-      ValidateAndNormalizeHighWaterMark = _require.ValidateAndNormalizeHighWaterMark;
-
-  var _require2 = __w_pdfjs_require__(0),
-      createArrayFromList = _require2.createArrayFromList,
-      createDataProperty = _require2.createDataProperty,
-      typeIsObject = _require2.typeIsObject;
-
-  var _require3 = __w_pdfjs_require__(1),
-      assert = _require3.assert,
-      rethrowAssertionErrorRejection = _require3.rethrowAssertionErrorRejection;
-
-  var _require4 = __w_pdfjs_require__(3),
-      DequeueValue = _require4.DequeueValue,
-      EnqueueValueWithSize = _require4.EnqueueValueWithSize,
-      ResetQueue = _require4.ResetQueue;
-
-  var _require5 = __w_pdfjs_require__(2),
-      AcquireWritableStreamDefaultWriter = _require5.AcquireWritableStreamDefaultWriter,
-      IsWritableStream = _require5.IsWritableStream,
-      IsWritableStreamLocked = _require5.IsWritableStreamLocked,
-      WritableStreamAbort = _require5.WritableStreamAbort,
-      WritableStreamDefaultWriterCloseWithErrorPropagation = _require5.WritableStreamDefaultWriterCloseWithErrorPropagation,
-      WritableStreamDefaultWriterRelease = _require5.WritableStreamDefaultWriterRelease,
-      WritableStreamDefaultWriterWrite = _require5.WritableStreamDefaultWriterWrite,
-      WritableStreamCloseQueuedOrInFlight = _require5.WritableStreamCloseQueuedOrInFlight;
-
-  var ReadableStream = function () {
-    function ReadableStream() {
-      var underlyingSource = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
-      var _ref = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-          size = _ref.size,
-          highWaterMark = _ref.highWaterMark;
-
-      _classCallCheck(this, ReadableStream);
-
-      this._state = 'readable';
-      this._reader = undefined;
-      this._storedError = undefined;
-      this._disturbed = false;
-      this._readableStreamController = undefined;
-      var type = underlyingSource.type;
-      var typeString = String(type);
-
-      if (typeString === 'bytes') {
-        if (highWaterMark === undefined) {
-          highWaterMark = 0;
-        }
-
-        this._readableStreamController = new ReadableByteStreamController(this, underlyingSource, highWaterMark);
-      } else if (type === undefined) {
-        if (highWaterMark === undefined) {
-          highWaterMark = 1;
-        }
-
-        this._readableStreamController = new ReadableStreamDefaultController(this, underlyingSource, size, highWaterMark);
-      } else {
-        throw new RangeError('Invalid type is specified');
-      }
-    }
-
-    _createClass(ReadableStream, [{
-      key: 'cancel',
-      value: function cancel(reason) {
-        if (IsReadableStream(this) === false) {
-          return Promise.reject(streamBrandCheckException('cancel'));
-        }
-
-        if (IsReadableStreamLocked(this) === true) {
-          return Promise.reject(new TypeError('Cannot cancel a stream that already has a reader'));
-        }
-
-        return ReadableStreamCancel(this, reason);
-      }
-    }, {
-      key: 'getReader',
-      value: function getReader() {
-        var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-            mode = _ref2.mode;
-
-        if (IsReadableStream(this) === false) {
-          throw streamBrandCheckException('getReader');
-        }
-
-        if (mode === undefined) {
-          return AcquireReadableStreamDefaultReader(this);
-        }
-
-        mode = String(mode);
-
-        if (mode === 'byob') {
-          return AcquireReadableStreamBYOBReader(this);
-        }
-
-        throw new RangeError('Invalid mode is specified');
-      }
-    }, {
-      key: 'pipeThrough',
-      value: function pipeThrough(_ref3, options) {
-        var writable = _ref3.writable,
-            readable = _ref3.readable;
-        var promise = this.pipeTo(writable, options);
-        ifIsObjectAndHasAPromiseIsHandledInternalSlotSetPromiseIsHandledToTrue(promise);
-        return readable;
-      }
-    }, {
-      key: 'pipeTo',
-      value: function pipeTo(dest) {
-        var _this = this;
-
-        var _ref4 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-            preventClose = _ref4.preventClose,
-            preventAbort = _ref4.preventAbort,
-            preventCancel = _ref4.preventCancel;
-
-        if (IsReadableStream(this) === false) {
-          return Promise.reject(streamBrandCheckException('pipeTo'));
-        }
-
-        if (IsWritableStream(dest) === false) {
-          return Promise.reject(new TypeError('ReadableStream.prototype.pipeTo\'s first argument must be a WritableStream'));
-        }
-
-        preventClose = Boolean(preventClose);
-        preventAbort = Boolean(preventAbort);
-        preventCancel = Boolean(preventCancel);
-
-        if (IsReadableStreamLocked(this) === true) {
-          return Promise.reject(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked ReadableStream'));
-        }
-
-        if (IsWritableStreamLocked(dest) === true) {
-          return Promise.reject(new TypeError('ReadableStream.prototype.pipeTo cannot be used on a locked WritableStream'));
-        }
-
-        var reader = AcquireReadableStreamDefaultReader(this);
-        var writer = AcquireWritableStreamDefaultWriter(dest);
-        var shuttingDown = false;
-        var currentWrite = Promise.resolve();
-        return new Promise(function (resolve, reject) {
-          function pipeLoop() {
-            currentWrite = Promise.resolve();
-
-            if (shuttingDown === true) {
-              return Promise.resolve();
-            }
-
-            return writer._readyPromise.then(function () {
-              return ReadableStreamDefaultReaderRead(reader).then(function (_ref5) {
-                var value = _ref5.value,
-                    done = _ref5.done;
-
-                if (done === true) {
-                  return;
-                }
-
-                currentWrite = WritableStreamDefaultWriterWrite(writer, value)["catch"](function () {});
-              });
-            }).then(pipeLoop);
-          }
-
-          isOrBecomesErrored(_this, reader._closedPromise, function (storedError) {
-            if (preventAbort === false) {
-              shutdownWithAction(function () {
-                return WritableStreamAbort(dest, storedError);
-              }, true, storedError);
-            } else {
-              shutdown(true, storedError);
-            }
-          });
-          isOrBecomesErrored(dest, writer._closedPromise, function (storedError) {
-            if (preventCancel === false) {
-              shutdownWithAction(function () {
-                return ReadableStreamCancel(_this, storedError);
-              }, true, storedError);
-            } else {
-              shutdown(true, storedError);
-            }
-          });
-          isOrBecomesClosed(_this, reader._closedPromise, function () {
-            if (preventClose === false) {
-              shutdownWithAction(function () {
-                return WritableStreamDefaultWriterCloseWithErrorPropagation(writer);
-              });
-            } else {
-              shutdown();
-            }
-          });
-
-          if (WritableStreamCloseQueuedOrInFlight(dest) === true || dest._state === 'closed') {
-            var destClosed = new TypeError('the destination writable stream closed before all data could be piped to it');
-
-            if (preventCancel === false) {
-              shutdownWithAction(function () {
-                return ReadableStreamCancel(_this, destClosed);
-              }, true, destClosed);
-            } else {
-              shutdown(true, destClosed);
-            }
-          }
-
-          pipeLoop()["catch"](function (err) {
-            currentWrite = Promise.resolve();
-            rethrowAssertionErrorRejection(err);
-          });
-
-          function waitForWritesToFinish() {
-            var oldCurrentWrite = currentWrite;
-            return currentWrite.then(function () {
-              return oldCurrentWrite !== currentWrite ? waitForWritesToFinish() : undefined;
-            });
-          }
-
-          function isOrBecomesErrored(stream, promise, action) {
-            if (stream._state === 'errored') {
-              action(stream._storedError);
-            } else {
-              promise["catch"](action)["catch"](rethrowAssertionErrorRejection);
-            }
-          }
-
-          function isOrBecomesClosed(stream, promise, action) {
-            if (stream._state === 'closed') {
-              action();
-            } else {
-              promise.then(action)["catch"](rethrowAssertionErrorRejection);
-            }
-          }
-
-          function shutdownWithAction(action, originalIsError, originalError) {
-            if (shuttingDown === true) {
-              return;
-            }
-
-            shuttingDown = true;
-
-            if (dest._state === 'writable' && WritableStreamCloseQueuedOrInFlight(dest) === false) {
-              waitForWritesToFinish().then(doTheRest);
-            } else {
-              doTheRest();
-            }
-
-            function doTheRest() {
-              action().then(function () {
-                return finalize(originalIsError, originalError);
-              }, function (newError) {
-                return finalize(true, newError);
-              })["catch"](rethrowAssertionErrorRejection);
-            }
-          }
-
-          function shutdown(isError, error) {
-            if (shuttingDown === true) {
-              return;
-            }
-
-            shuttingDown = true;
-
-            if (dest._state === 'writable' && WritableStreamCloseQueuedOrInFlight(dest) === false) {
-              waitForWritesToFinish().then(function () {
-                return finalize(isError, error);
-              })["catch"](rethrowAssertionErrorRejection);
-            } else {
-              finalize(isError, error);
-            }
-          }
-
-          function finalize(isError, error) {
-            WritableStreamDefaultWriterRelease(writer);
-            ReadableStreamReaderGenericRelease(reader);
-
-            if (isError) {
-              reject(error);
-            } else {
-              resolve(undefined);
-            }
-          }
-        });
-      }
-    }, {
-      key: 'tee',
-      value: function tee() {
-        if (IsReadableStream(this) === false) {
-          throw streamBrandCheckException('tee');
-        }
-
-        var branches = ReadableStreamTee(this, false);
-        return createArrayFromList(branches);
-      }
-    }, {
-      key: 'locked',
-      get: function get() {
-        if (IsReadableStream(this) === false) {
-          throw streamBrandCheckException('locked');
-        }
-
-        return IsReadableStreamLocked(this);
-      }
-    }]);
-
-    return ReadableStream;
-  }();
-
-  module.exports = {
-    ReadableStream: ReadableStream,
-    IsReadableStreamDisturbed: IsReadableStreamDisturbed,
-    ReadableStreamDefaultControllerClose: ReadableStreamDefaultControllerClose,
-    ReadableStreamDefaultControllerEnqueue: ReadableStreamDefaultControllerEnqueue,
-    ReadableStreamDefaultControllerError: ReadableStreamDefaultControllerError,
-    ReadableStreamDefaultControllerGetDesiredSize: ReadableStreamDefaultControllerGetDesiredSize
-  };
-
-  function AcquireReadableStreamBYOBReader(stream) {
-    return new ReadableStreamBYOBReader(stream);
-  }
-
-  function AcquireReadableStreamDefaultReader(stream) {
-    return new ReadableStreamDefaultReader(stream);
-  }
-
-  function IsReadableStream(x) {
-    if (!typeIsObject(x)) {
-      return false;
-    }
-
-    if (!Object.prototype.hasOwnProperty.call(x, '_readableStreamController')) {
-      return false;
-    }
-
-    return true;
-  }
-
-  function IsReadableStreamDisturbed(stream) {
-    assert(IsReadableStream(stream) === true, 'IsReadableStreamDisturbed should only be used on known readable streams');
-    return stream._disturbed;
-  }
-
-  function IsReadableStreamLocked(stream) {
-    assert(IsReadableStream(stream) === true, 'IsReadableStreamLocked should only be used on known readable streams');
-
-    if (stream._reader === undefined) {
-      return false;
-    }
-
-    return true;
-  }
-
-  function ReadableStreamTee(stream, cloneForBranch2) {
-    assert(IsReadableStream(stream) === true);
-    assert(typeof cloneForBranch2 === 'boolean');
-    var reader = AcquireReadableStreamDefaultReader(stream);
-    var teeState = {
-      closedOrErrored: false,
-      canceled1: false,
-      canceled2: false,
-      reason1: undefined,
-      reason2: undefined
-    };
-    teeState.promise = new Promise(function (resolve) {
-      teeState._resolve = resolve;
-    });
-    var pull = create_ReadableStreamTeePullFunction();
-    pull._reader = reader;
-    pull._teeState = teeState;
-    pull._cloneForBranch2 = cloneForBranch2;
-    var cancel1 = create_ReadableStreamTeeBranch1CancelFunction();
-    cancel1._stream = stream;
-    cancel1._teeState = teeState;
-    var cancel2 = create_ReadableStreamTeeBranch2CancelFunction();
-    cancel2._stream = stream;
-    cancel2._teeState = teeState;
-    var underlyingSource1 = Object.create(Object.prototype);
-    createDataProperty(underlyingSource1, 'pull', pull);
-    createDataProperty(underlyingSource1, 'cancel', cancel1);
-    var branch1Stream = new ReadableStream(underlyingSource1);
-    var underlyingSource2 = Object.create(Object.prototype);
-    createDataProperty(underlyingSource2, 'pull', pull);
-    createDataProperty(underlyingSource2, 'cancel', cancel2);
-    var branch2Stream = new ReadableStream(underlyingSource2);
-    pull._branch1 = branch1Stream._readableStreamController;
-    pull._branch2 = branch2Stream._readableStreamController;
-
-    reader._closedPromise["catch"](function (r) {
-      if (teeState.closedOrErrored === true) {
-        return;
-      }
-
-      ReadableStreamDefaultControllerError(pull._branch1, r);
-      ReadableStreamDefaultControllerError(pull._branch2, r);
-      teeState.closedOrErrored = true;
-    });
-
-    return [branch1Stream, branch2Stream];
-  }
-
-  function create_ReadableStreamTeePullFunction() {
-    function f() {
-      var reader = f._reader,
-          branch1 = f._branch1,
-          branch2 = f._branch2,
-          teeState = f._teeState;
-      return ReadableStreamDefaultReaderRead(reader).then(function (result) {
-        assert(typeIsObject(result));
-        var value = result.value;
-        var done = result.done;
-        assert(typeof done === 'boolean');
-
-        if (done === true && teeState.closedOrErrored === false) {
-          if (teeState.canceled1 === false) {
-            ReadableStreamDefaultControllerClose(branch1);
-          }
-
-          if (teeState.canceled2 === false) {
-            ReadableStreamDefaultControllerClose(branch2);
-          }
-
-          teeState.closedOrErrored = true;
-        }
-
-        if (teeState.closedOrErrored === true) {
-          return;
-        }
-
-        var value1 = value;
-        var value2 = value;
-
-        if (teeState.canceled1 === false) {
-          ReadableStreamDefaultControllerEnqueue(branch1, value1);
-        }
-
-        if (teeState.canceled2 === false) {
-          ReadableStreamDefaultControllerEnqueue(branch2, value2);
-        }
-      });
-    }
-
-    return f;
-  }
-
-  function create_ReadableStreamTeeBranch1CancelFunction() {
-    function f(reason) {
-      var stream = f._stream,
-          teeState = f._teeState;
-      teeState.canceled1 = true;
-      teeState.reason1 = reason;
-
-      if (teeState.canceled2 === true) {
-        var compositeReason = createArrayFromList([teeState.reason1, teeState.reason2]);
-        var cancelResult = ReadableStreamCancel(stream, compositeReason);
-
-        teeState._resolve(cancelResult);
-      }
-
-      return teeState.promise;
-    }
-
-    return f;
-  }
-
-  function create_ReadableStreamTeeBranch2CancelFunction() {
-    function f(reason) {
-      var stream = f._stream,
-          teeState = f._teeState;
-      teeState.canceled2 = true;
-      teeState.reason2 = reason;
-
-      if (teeState.canceled1 === true) {
-        var compositeReason = createArrayFromList([teeState.reason1, teeState.reason2]);
-        var cancelResult = ReadableStreamCancel(stream, compositeReason);
-
-        teeState._resolve(cancelResult);
-      }
-
-      return teeState.promise;
-    }
-
-    return f;
-  }
-
-  function ReadableStreamAddReadIntoRequest(stream) {
-    assert(IsReadableStreamBYOBReader(stream._reader) === true);
-    assert(stream._state === 'readable' || stream._state === 'closed');
-    var promise = new Promise(function (resolve, reject) {
-      var readIntoRequest = {
-        _resolve: resolve,
-        _reject: reject
-      };
-
-      stream._reader._readIntoRequests.push(readIntoRequest);
-    });
-    return promise;
-  }
-
-  function ReadableStreamAddReadRequest(stream) {
-    assert(IsReadableStreamDefaultReader(stream._reader) === true);
-    assert(stream._state === 'readable');
-    var promise = new Promise(function (resolve, reject) {
-      var readRequest = {
-        _resolve: resolve,
-        _reject: reject
-      };
-
-      stream._reader._readRequests.push(readRequest);
-    });
-    return promise;
-  }
-
-  function ReadableStreamCancel(stream, reason) {
-    stream._disturbed = true;
-
-    if (stream._state === 'closed') {
-      return Promise.resolve(undefined);
-    }
-
-    if (stream._state === 'errored') {
-      return Promise.reject(stream._storedError);
-    }
-
-    ReadableStreamClose(stream);
-
-    var sourceCancelPromise = stream._readableStreamController.__cancelSteps(reason);
-
-    return sourceCancelPromise.then(function () {
-      return undefined;
-    });
-  }
-
-  function ReadableStreamClose(stream) {
-    assert(stream._state === 'readable');
-    stream._state = 'closed';
-    var reader = stream._reader;
-
-    if (reader === undefined) {
-      return undefined;
-    }
-
-    if (IsReadableStreamDefaultReader(reader) === true) {
-      for (var i = 0; i < reader._readRequests.length; i++) {
-        var _resolve = reader._readRequests[i]._resolve;
-
-        _resolve(CreateIterResultObject(undefined, true));
-      }
-
-      reader._readRequests = [];
-    }
-
-    defaultReaderClosedPromiseResolve(reader);
-    return undefined;
-  }
-
-  function ReadableStreamError(stream, e) {
-    assert(IsReadableStream(stream) === true, 'stream must be ReadableStream');
-    assert(stream._state === 'readable', 'state must be readable');
-    stream._state = 'errored';
-    stream._storedError = e;
-    var reader = stream._reader;
-
-    if (reader === undefined) {
-      return undefined;
-    }
-
-    if (IsReadableStreamDefaultReader(reader) === true) {
-      for (var i = 0; i < reader._readRequests.length; i++) {
-        var readRequest = reader._readRequests[i];
-
-        readRequest._reject(e);
-      }
-
-      reader._readRequests = [];
-    } else {
-      assert(IsReadableStreamBYOBReader(reader), 'reader must be ReadableStreamBYOBReader');
-
-      for (var _i = 0; _i < reader._readIntoRequests.length; _i++) {
-        var readIntoRequest = reader._readIntoRequests[_i];
-
-        readIntoRequest._reject(e);
-      }
-
-      reader._readIntoRequests = [];
-    }
-
-    defaultReaderClosedPromiseReject(reader, e);
-
-    reader._closedPromise["catch"](function () {});
-  }
-
-  function ReadableStreamFulfillReadIntoRequest(stream, chunk, done) {
-    var reader = stream._reader;
-    assert(reader._readIntoRequests.length > 0);
-
-    var readIntoRequest = reader._readIntoRequests.shift();
-
-    readIntoRequest._resolve(CreateIterResultObject(chunk, done));
-  }
-
-  function ReadableStreamFulfillReadRequest(stream, chunk, done) {
-    var reader = stream._reader;
-    assert(reader._readRequests.length > 0);
-
-    var readRequest = reader._readRequests.shift();
-
-    readRequest._resolve(CreateIterResultObject(chunk, done));
-  }
-
-  function ReadableStreamGetNumReadIntoRequests(stream) {
-    return stream._reader._readIntoRequests.length;
-  }
-
-  function ReadableStreamGetNumReadRequests(stream) {
-    return stream._reader._readRequests.length;
-  }
-
-  function ReadableStreamHasBYOBReader(stream) {
-    var reader = stream._reader;
-
-    if (reader === undefined) {
-      return false;
-    }
-
-    if (IsReadableStreamBYOBReader(reader) === false) {
-      return false;
-    }
-
-    return true;
-  }
-
-  function ReadableStreamHasDefaultReader(stream) {
-    var reader = stream._reader;
-
-    if (reader === undefined) {
-      return false;
-    }
-
-    if (IsReadableStreamDefaultReader(reader) === false) {
-      return false;
-    }
-
-    return true;
-  }
-
-  var ReadableStreamDefaultReader = function () {
-    function ReadableStreamDefaultReader(stream) {
-      _classCallCheck(this, ReadableStreamDefaultReader);
-
-      if (IsReadableStream(stream) === false) {
-        throw new TypeError('ReadableStreamDefaultReader can only be constructed with a ReadableStream instance');
-      }
-
-      if (IsReadableStreamLocked(stream) === true) {
-        throw new TypeError('This stream has already been locked for exclusive reading by another reader');
-      }
-
-      ReadableStreamReaderGenericInitialize(this, stream);
-      this._readRequests = [];
-    }
-
-    _createClass(ReadableStreamDefaultReader, [{
-      key: 'cancel',
-      value: function cancel(reason) {
-        if (IsReadableStreamDefaultReader(this) === false) {
-          return Promise.reject(defaultReaderBrandCheckException('cancel'));
-        }
-
-        if (this._ownerReadableStream === undefined) {
-          return Promise.reject(readerLockException('cancel'));
-        }
-
-        return ReadableStreamReaderGenericCancel(this, reason);
-      }
-    }, {
-      key: 'read',
-      value: function read() {
-        if (IsReadableStreamDefaultReader(this) === false) {
-          return Promise.reject(defaultReaderBrandCheckException('read'));
-        }
-
-        if (this._ownerReadableStream === undefined) {
-          return Promise.reject(readerLockException('read from'));
-        }
-
-        return ReadableStreamDefaultReaderRead(this);
-      }
-    }, {
-      key: 'releaseLock',
-      value: function releaseLock() {
-        if (IsReadableStreamDefaultReader(this) === false) {
-          throw defaultReaderBrandCheckException('releaseLock');
-        }
-
-        if (this._ownerReadableStream === undefined) {
-          return;
-        }
-
-        if (this._readRequests.length > 0) {
-          throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');
-        }
-
-        ReadableStreamReaderGenericRelease(this);
-      }
-    }, {
-      key: 'closed',
-      get: function get() {
-        if (IsReadableStreamDefaultReader(this) === false) {
-          return Promise.reject(defaultReaderBrandCheckException('closed'));
-        }
-
-        return this._closedPromise;
-      }
-    }]);
-
-    return ReadableStreamDefaultReader;
-  }();
-
-  var ReadableStreamBYOBReader = function () {
-    function ReadableStreamBYOBReader(stream) {
-      _classCallCheck(this, ReadableStreamBYOBReader);
-
-      if (!IsReadableStream(stream)) {
-        throw new TypeError('ReadableStreamBYOBReader can only be constructed with a ReadableStream instance given a ' + 'byte source');
-      }
-
-      if (IsReadableByteStreamController(stream._readableStreamController) === false) {
-        throw new TypeError('Cannot construct a ReadableStreamBYOBReader for a stream not constructed with a byte ' + 'source');
-      }
-
-      if (IsReadableStreamLocked(stream)) {
-        throw new TypeError('This stream has already been locked for exclusive reading by another reader');
-      }
-
-      ReadableStreamReaderGenericInitialize(this, stream);
-      this._readIntoRequests = [];
-    }
-
-    _createClass(ReadableStreamBYOBReader, [{
-      key: 'cancel',
-      value: function cancel(reason) {
-        if (!IsReadableStreamBYOBReader(this)) {
-          return Promise.reject(byobReaderBrandCheckException('cancel'));
-        }
-
-        if (this._ownerReadableStream === undefined) {
-          return Promise.reject(readerLockException('cancel'));
-        }
-
-        return ReadableStreamReaderGenericCancel(this, reason);
-      }
-    }, {
-      key: 'read',
-      value: function read(view) {
-        if (!IsReadableStreamBYOBReader(this)) {
-          return Promise.reject(byobReaderBrandCheckException('read'));
-        }
-
-        if (this._ownerReadableStream === undefined) {
-          return Promise.reject(readerLockException('read from'));
-        }
-
-        if (!ArrayBuffer.isView(view)) {
-          return Promise.reject(new TypeError('view must be an array buffer view'));
-        }
-
-        if (view.byteLength === 0) {
-          return Promise.reject(new TypeError('view must have non-zero byteLength'));
-        }
-
-        return ReadableStreamBYOBReaderRead(this, view);
-      }
-    }, {
-      key: 'releaseLock',
-      value: function releaseLock() {
-        if (!IsReadableStreamBYOBReader(this)) {
-          throw byobReaderBrandCheckException('releaseLock');
-        }
-
-        if (this._ownerReadableStream === undefined) {
-          return;
-        }
-
-        if (this._readIntoRequests.length > 0) {
-          throw new TypeError('Tried to release a reader lock when that reader has pending read() calls un-settled');
-        }
-
-        ReadableStreamReaderGenericRelease(this);
-      }
-    }, {
-      key: 'closed',
-      get: function get() {
-        if (!IsReadableStreamBYOBReader(this)) {
-          return Promise.reject(byobReaderBrandCheckException('closed'));
-        }
-
-        return this._closedPromise;
-      }
-    }]);
-
-    return ReadableStreamBYOBReader;
-  }();
-
-  function IsReadableStreamBYOBReader(x) {
-    if (!typeIsObject(x)) {
-      return false;
-    }
-
-    if (!Object.prototype.hasOwnProperty.call(x, '_readIntoRequests')) {
-      return false;
-    }
-
-    return true;
-  }
-
-  function IsReadableStreamDefaultReader(x) {
-    if (!typeIsObject(x)) {
-      return false;
-    }
-
-    if (!Object.prototype.hasOwnProperty.call(x, '_readRequests')) {
-      return false;
-    }
-
-    return true;
-  }
-
-  function ReadableStreamReaderGenericInitialize(reader, stream) {
-    reader._ownerReadableStream = stream;
-    stream._reader = reader;
-
-    if (stream._state === 'readable') {
-      defaultReaderClosedPromiseInitialize(reader);
-    } else if (stream._state === 'closed') {
-      defaultReaderClosedPromiseInitializeAsResolved(reader);
-    } else {
-      assert(stream._state === 'errored', 'state must be errored');
-      defaultReaderClosedPromiseInitializeAsRejected(reader, stream._storedError);
-
-      reader._closedPromise["catch"](function () {});
-    }
-  }
-
-  function ReadableStreamReaderGenericCancel(reader, reason) {
-    var stream = reader._ownerReadableStream;
-    assert(stream !== undefined);
-    return ReadableStreamCancel(stream, reason);
-  }
-
-  function ReadableStreamReaderGenericRelease(reader) {
-    assert(reader._ownerReadableStream !== undefined);
-    assert(reader._ownerReadableStream._reader === reader);
-
-    if (reader._ownerReadableStream._state === 'readable') {
-      defaultReaderClosedPromiseReject(reader, new TypeError('Reader was released and can no longer be used to monitor the stream\'s closedness'));
-    } else {
-      defaultReaderClosedPromiseResetToRejected(reader, new TypeError('Reader was released and can no longer be used to monitor the stream\'s closedness'));
-    }
-
-    reader._closedPromise["catch"](function () {});
-
-    reader._ownerReadableStream._reader = undefined;
-    reader._ownerReadableStream = undefined;
-  }
-
-  function ReadableStreamBYOBReaderRead(reader, view) {
-    var stream = reader._ownerReadableStream;
-    assert(stream !== undefined);
-    stream._disturbed = true;
-
-    if (stream._state === 'errored') {
-      return Promise.reject(stream._storedError);
-    }
-
-    return ReadableByteStreamControllerPullInto(stream._readableStreamController, view);
-  }
-
-  function ReadableStreamDefaultReaderRead(reader) {
-    var stream = reader._ownerReadableStream;
-    assert(stream !== undefined);
-    stream._disturbed = true;
-
-    if (stream._state === 'closed') {
-      return Promise.resolve(CreateIterResultObject(undefined, true));
-    }
-
-    if (stream._state === 'errored') {
-      return Promise.reject(stream._storedError);
-    }
-
-    assert(stream._state === 'readable');
-    return stream._readableStreamController.__pullSteps();
-  }
-
-  var ReadableStreamDefaultController = function () {
-    function ReadableStreamDefaultController(stream, underlyingSource, size, highWaterMark) {
-      _classCallCheck(this, ReadableStreamDefaultController);
-
-      if (IsReadableStream(stream) === false) {
-        throw new TypeError('ReadableStreamDefaultController can only be constructed with a ReadableStream instance');
-      }
-
-      if (stream._readableStreamController !== undefined) {
-        throw new TypeError('ReadableStreamDefaultController instances can only be created by the ReadableStream constructor');
-      }
-
-      this._controlledReadableStream = stream;
-      this._underlyingSource = underlyingSource;
-      this._queue = undefined;
-      this._queueTotalSize = undefined;
-      ResetQueue(this);
-      this._started = false;
-      this._closeRequested = false;
-      this._pullAgain = false;
-      this._pulling = false;
-      var normalizedStrategy = ValidateAndNormalizeQueuingStrategy(size, highWaterMark);
-      this._strategySize = normalizedStrategy.size;
-      this._strategyHWM = normalizedStrategy.highWaterMark;
-      var controller = this;
-      var startResult = InvokeOrNoop(underlyingSource, 'start', [this]);
-      Promise.resolve(startResult).then(function () {
-        controller._started = true;
-        assert(controller._pulling === false);
-        assert(controller._pullAgain === false);
-        ReadableStreamDefaultControllerCallPullIfNeeded(controller);
-      }, function (r) {
-        ReadableStreamDefaultControllerErrorIfNeeded(controller, r);
-      })["catch"](rethrowAssertionErrorRejection);
-    }
-
-    _createClass(ReadableStreamDefaultController, [{
-      key: 'close',
-      value: function close() {
-        if (IsReadableStreamDefaultController(this) === false) {
-          throw defaultControllerBrandCheckException('close');
-        }
-
-        if (this._closeRequested === true) {
-          throw new TypeError('The stream has already been closed; do not close it again!');
-        }
-
-        var state = this._controlledReadableStream._state;
-
-        if (state !== 'readable') {
-          throw new TypeError('The stream (in ' + state + ' state) is not in the readable state and cannot be closed');
-        }
-
-        ReadableStreamDefaultControllerClose(this);
-      }
-    }, {
-      key: 'enqueue',
-      value: function enqueue(chunk) {
-        if (IsReadableStreamDefaultController(this) === false) {
-          throw defaultControllerBrandCheckException('enqueue');
-        }
-
-        if (this._closeRequested === true) {
-          throw new TypeError('stream is closed or draining');
-        }
-
-        var state = this._controlledReadableStream._state;
-
-        if (state !== 'readable') {
-          throw new TypeError('The stream (in ' + state + ' state) is not in the readable state and cannot be enqueued to');
-        }
-
-        return ReadableStreamDefaultControllerEnqueue(this, chunk);
-      }
-    }, {
-      key: 'error',
-      value: function error(e) {
-        if (IsReadableStreamDefaultController(this) === false) {
-          throw defaultControllerBrandCheckException('error');
-        }
-
-        var stream = this._controlledReadableStream;
-
-        if (stream._state !== 'readable') {
-          throw new TypeError('The stream is ' + stream._state + ' and so cannot be errored');
-        }
-
-        ReadableStreamDefaultControllerError(this, e);
-      }
-    }, {
-      key: '__cancelSteps',
-      value: function __cancelSteps(reason) {
-        ResetQueue(this);
-        return PromiseInvokeOrNoop(this._underlyingSource, 'cancel', [reason]);
-      }
-    }, {
-      key: '__pullSteps',
-      value: function __pullSteps() {
-        var stream = this._controlledReadableStream;
-
-        if (this._queue.length > 0) {
-          var chunk = DequeueValue(this);
-
-          if (this._closeRequested === true && this._queue.length === 0) {
-            ReadableStreamClose(stream);
-          } else {
-            ReadableStreamDefaultControllerCallPullIfNeeded(this);
-          }
-
-          return Promise.resolve(CreateIterResultObject(chunk, false));
-        }
-
-        var pendingPromise = ReadableStreamAddReadRequest(stream);
-        ReadableStreamDefaultControllerCallPullIfNeeded(this);
-        return pendingPromise;
-      }
-    }, {
-      key: 'desiredSize',
-      get: function get() {
-        if (IsReadableStreamDefaultController(this) === false) {
-          throw defaultControllerBrandCheckException('desiredSize');
-        }
-
-        return ReadableStreamDefaultControllerGetDesiredSize(this);
-      }
-    }]);
-
-    return ReadableStreamDefaultController;
-  }();
-
-  function IsReadableStreamDefaultController(x) {
-    if (!typeIsObject(x)) {
-      return false;
-    }
-
-    if (!Object.prototype.hasOwnProperty.call(x, '_underlyingSource')) {
-      return false;
-    }
-
-    return true;
-  }
-
-  function ReadableStreamDefaultControllerCallPullIfNeeded(controller) {
-    var shouldPull = ReadableStreamDefaultControllerShouldCallPull(controller);
-
-    if (shouldPull === false) {
-      return undefined;
-    }
-
-    if (controller._pulling === true) {
-      controller._pullAgain = true;
-      return undefined;
-    }
-
-    assert(controller._pullAgain === false);
-    controller._pulling = true;
-    var pullPromise = PromiseInvokeOrNoop(controller._underlyingSource, 'pull', [controller]);
-    pullPromise.then(function () {
-      controller._pulling = false;
-
-      if (controller._pullAgain === true) {
-        controller._pullAgain = false;
-        return ReadableStreamDefaultControllerCallPullIfNeeded(controller);
-      }
-
-      return undefined;
-    }, function (e) {
-      ReadableStreamDefaultControllerErrorIfNeeded(controller, e);
-    })["catch"](rethrowAssertionErrorRejection);
-    return undefined;
-  }
-
-  function ReadableStreamDefaultControllerShouldCallPull(controller) {
-    var stream = controller._controlledReadableStream;
-
-    if (stream._state === 'closed' || stream._state === 'errored') {
-      return false;
-    }
-
-    if (controller._closeRequested === true) {
-      return false;
-    }
-
-    if (controller._started === false) {
-      return false;
-    }
-
-    if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
-      return true;
-    }
-
-    var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);
-
-    if (desiredSize > 0) {
-      return true;
-    }
-
-    return false;
-  }
-
-  function ReadableStreamDefaultControllerClose(controller) {
-    var stream = controller._controlledReadableStream;
-    assert(controller._closeRequested === false);
-    assert(stream._state === 'readable');
-    controller._closeRequested = true;
-
-    if (controller._queue.length === 0) {
-      ReadableStreamClose(stream);
-    }
-  }
-
-  function ReadableStreamDefaultControllerEnqueue(controller, chunk) {
-    var stream = controller._controlledReadableStream;
-    assert(controller._closeRequested === false);
-    assert(stream._state === 'readable');
-
-    if (IsReadableStreamLocked(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
-      ReadableStreamFulfillReadRequest(stream, chunk, false);
-    } else {
-      var chunkSize = 1;
-
-      if (controller._strategySize !== undefined) {
-        var strategySize = controller._strategySize;
-
-        try {
-          chunkSize = strategySize(chunk);
-        } catch (chunkSizeE) {
-          ReadableStreamDefaultControllerErrorIfNeeded(controller, chunkSizeE);
-          throw chunkSizeE;
-        }
-      }
-
-      try {
-        EnqueueValueWithSize(controller, chunk, chunkSize);
-      } catch (enqueueE) {
-        ReadableStreamDefaultControllerErrorIfNeeded(controller, enqueueE);
-        throw enqueueE;
-      }
-    }
-
-    ReadableStreamDefaultControllerCallPullIfNeeded(controller);
-    return undefined;
-  }
-
-  function ReadableStreamDefaultControllerError(controller, e) {
-    var stream = controller._controlledReadableStream;
-    assert(stream._state === 'readable');
-    ResetQueue(controller);
-    ReadableStreamError(stream, e);
-  }
-
-  function ReadableStreamDefaultControllerErrorIfNeeded(controller, e) {
-    if (controller._controlledReadableStream._state === 'readable') {
-      ReadableStreamDefaultControllerError(controller, e);
-    }
-  }
-
-  function ReadableStreamDefaultControllerGetDesiredSize(controller) {
-    var stream = controller._controlledReadableStream;
-    var state = stream._state;
-
-    if (state === 'errored') {
-      return null;
-    }
-
-    if (state === 'closed') {
-      return 0;
-    }
-
-    return controller._strategyHWM - controller._queueTotalSize;
-  }
-
-  var ReadableStreamBYOBRequest = function () {
-    function ReadableStreamBYOBRequest(controller, view) {
-      _classCallCheck(this, ReadableStreamBYOBRequest);
-
-      this._associatedReadableByteStreamController = controller;
-      this._view = view;
-    }
-
-    _createClass(ReadableStreamBYOBRequest, [{
-      key: 'respond',
-      value: function respond(bytesWritten) {
-        if (IsReadableStreamBYOBRequest(this) === false) {
-          throw byobRequestBrandCheckException('respond');
-        }
-
-        if (this._associatedReadableByteStreamController === undefined) {
-          throw new TypeError('This BYOB request has been invalidated');
-        }
-
-        ReadableByteStreamControllerRespond(this._associatedReadableByteStreamController, bytesWritten);
-      }
-    }, {
-      key: 'respondWithNewView',
-      value: function respondWithNewView(view) {
-        if (IsReadableStreamBYOBRequest(this) === false) {
-          throw byobRequestBrandCheckException('respond');
-        }
-
-        if (this._associatedReadableByteStreamController === undefined) {
-          throw new TypeError('This BYOB request has been invalidated');
-        }
-
-        if (!ArrayBuffer.isView(view)) {
-          throw new TypeError('You can only respond with array buffer views');
-        }
-
-        ReadableByteStreamControllerRespondWithNewView(this._associatedReadableByteStreamController, view);
-      }
-    }, {
-      key: 'view',
-      get: function get() {
-        return this._view;
-      }
-    }]);
-
-    return ReadableStreamBYOBRequest;
-  }();
-
-  var ReadableByteStreamController = function () {
-    function ReadableByteStreamController(stream, underlyingByteSource, highWaterMark) {
-      _classCallCheck(this, ReadableByteStreamController);
-
-      if (IsReadableStream(stream) === false) {
-        throw new TypeError('ReadableByteStreamController can only be constructed with a ReadableStream instance given ' + 'a byte source');
-      }
-
-      if (stream._readableStreamController !== undefined) {
-        throw new TypeError('ReadableByteStreamController instances can only be created by the ReadableStream constructor given a byte ' + 'source');
-      }
-
-      this._controlledReadableStream = stream;
-      this._underlyingByteSource = underlyingByteSource;
-      this._pullAgain = false;
-      this._pulling = false;
-      ReadableByteStreamControllerClearPendingPullIntos(this);
-      this._queue = this._queueTotalSize = undefined;
-      ResetQueue(this);
-      this._closeRequested = false;
-      this._started = false;
-      this._strategyHWM = ValidateAndNormalizeHighWaterMark(highWaterMark);
-      var autoAllocateChunkSize = underlyingByteSource.autoAllocateChunkSize;
-
-      if (autoAllocateChunkSize !== undefined) {
-        if (Number.isInteger(autoAllocateChunkSize) === false || autoAllocateChunkSize <= 0) {
-          throw new RangeError('autoAllocateChunkSize must be a positive integer');
-        }
-      }
-
-      this._autoAllocateChunkSize = autoAllocateChunkSize;
-      this._pendingPullIntos = [];
-      var controller = this;
-      var startResult = InvokeOrNoop(underlyingByteSource, 'start', [this]);
-      Promise.resolve(startResult).then(function () {
-        controller._started = true;
-        assert(controller._pulling === false);
-        assert(controller._pullAgain === false);
-        ReadableByteStreamControllerCallPullIfNeeded(controller);
-      }, function (r) {
-        if (stream._state === 'readable') {
-          ReadableByteStreamControllerError(controller, r);
-        }
-      })["catch"](rethrowAssertionErrorRejection);
-    }
-
-    _createClass(ReadableByteStreamController, [{
-      key: 'close',
-      value: function close() {
-        if (IsReadableByteStreamController(this) === false) {
-          throw byteStreamControllerBrandCheckException('close');
-        }
-
-        if (this._closeRequested === true) {
-          throw new TypeError('The stream has already been closed; do not close it again!');
-        }
-
-        var state = this._controlledReadableStream._state;
-
-        if (state !== 'readable') {
-          throw new TypeError('The stream (in ' + state + ' state) is not in the readable state and cannot be closed');
-        }
-
-        ReadableByteStreamControllerClose(this);
-      }
-    }, {
-      key: 'enqueue',
-      value: function enqueue(chunk) {
-        if (IsReadableByteStreamController(this) === false) {
-          throw byteStreamControllerBrandCheckException('enqueue');
-        }
-
-        if (this._closeRequested === true) {
-          throw new TypeError('stream is closed or draining');
-        }
-
-        var state = this._controlledReadableStream._state;
-
-        if (state !== 'readable') {
-          throw new TypeError('The stream (in ' + state + ' state) is not in the readable state and cannot be enqueued to');
-        }
-
-        if (!ArrayBuffer.isView(chunk)) {
-          throw new TypeError('You can only enqueue array buffer views when using a ReadableByteStreamController');
-        }
-
-        ReadableByteStreamControllerEnqueue(this, chunk);
-      }
-    }, {
-      key: 'error',
-      value: function error(e) {
-        if (IsReadableByteStreamController(this) === false) {
-          throw byteStreamControllerBrandCheckException('error');
-        }
-
-        var stream = this._controlledReadableStream;
-
-        if (stream._state !== 'readable') {
-          throw new TypeError('The stream is ' + stream._state + ' and so cannot be errored');
-        }
-
-        ReadableByteStreamControllerError(this, e);
-      }
-    }, {
-      key: '__cancelSteps',
-      value: function __cancelSteps(reason) {
-        if (this._pendingPullIntos.length > 0) {
-          var firstDescriptor = this._pendingPullIntos[0];
-          firstDescriptor.bytesFilled = 0;
-        }
-
-        ResetQueue(this);
-        return PromiseInvokeOrNoop(this._underlyingByteSource, 'cancel', [reason]);
-      }
-    }, {
-      key: '__pullSteps',
-      value: function __pullSteps() {
-        var stream = this._controlledReadableStream;
-        assert(ReadableStreamHasDefaultReader(stream) === true);
-
-        if (this._queueTotalSize > 0) {
-          assert(ReadableStreamGetNumReadRequests(stream) === 0);
-
-          var entry = this._queue.shift();
-
-          this._queueTotalSize -= entry.byteLength;
-          ReadableByteStreamControllerHandleQueueDrain(this);
-          var view = void 0;
-
-          try {
-            view = new Uint8Array(entry.buffer, entry.byteOffset, entry.byteLength);
-          } catch (viewE) {
-            return Promise.reject(viewE);
-          }
-
-          return Promise.resolve(CreateIterResultObject(view, false));
-        }
-
-        var autoAllocateChunkSize = this._autoAllocateChunkSize;
-
-        if (autoAllocateChunkSize !== undefined) {
-          var buffer = void 0;
-
-          try {
-            buffer = new ArrayBuffer(autoAllocateChunkSize);
-          } catch (bufferE) {
-            return Promise.reject(bufferE);
-          }
-
-          var pullIntoDescriptor = {
-            buffer: buffer,
-            byteOffset: 0,
-            byteLength: autoAllocateChunkSize,
-            bytesFilled: 0,
-            elementSize: 1,
-            ctor: Uint8Array,
-            readerType: 'default'
-          };
-
-          this._pendingPullIntos.push(pullIntoDescriptor);
-        }
-
-        var promise = ReadableStreamAddReadRequest(stream);
-        ReadableByteStreamControllerCallPullIfNeeded(this);
-        return promise;
-      }
-    }, {
-      key: 'byobRequest',
-      get: function get() {
-        if (IsReadableByteStreamController(this) === false) {
-          throw byteStreamControllerBrandCheckException('byobRequest');
-        }
-
-        if (this._byobRequest === undefined && this._pendingPullIntos.length > 0) {
-          var firstDescriptor = this._pendingPullIntos[0];
-          var view = new Uint8Array(firstDescriptor.buffer, firstDescriptor.byteOffset + firstDescriptor.bytesFilled, firstDescriptor.byteLength - firstDescriptor.bytesFilled);
-          this._byobRequest = new ReadableStreamBYOBRequest(this, view);
-        }
-
-        return this._byobRequest;
-      }
-    }, {
-      key: 'desiredSize',
-      get: function get() {
-        if (IsReadableByteStreamController(this) === false) {
-          throw byteStreamControllerBrandCheckException('desiredSize');
-        }
-
-        return ReadableByteStreamControllerGetDesiredSize(this);
-      }
-    }]);
-
-    return ReadableByteStreamController;
-  }();
-
-  function IsReadableByteStreamController(x) {
-    if (!typeIsObject(x)) {
-      return false;
-    }
-
-    if (!Object.prototype.hasOwnProperty.call(x, '_underlyingByteSource')) {
-      return false;
-    }
-
-    return true;
-  }
-
-  function IsReadableStreamBYOBRequest(x) {
-    if (!typeIsObject(x)) {
-      return false;
-    }
-
-    if (!Object.prototype.hasOwnProperty.call(x, '_associatedReadableByteStreamController')) {
-      return false;
-    }
-
-    return true;
-  }
-
-  function ReadableByteStreamControllerCallPullIfNeeded(controller) {
-    var shouldPull = ReadableByteStreamControllerShouldCallPull(controller);
-
-    if (shouldPull === false) {
-      return undefined;
-    }
-
-    if (controller._pulling === true) {
-      controller._pullAgain = true;
-      return undefined;
-    }
-
-    assert(controller._pullAgain === false);
-    controller._pulling = true;
-    var pullPromise = PromiseInvokeOrNoop(controller._underlyingByteSource, 'pull', [controller]);
-    pullPromise.then(function () {
-      controller._pulling = false;
-
-      if (controller._pullAgain === true) {
-        controller._pullAgain = false;
-        ReadableByteStreamControllerCallPullIfNeeded(controller);
-      }
-    }, function (e) {
-      if (controller._controlledReadableStream._state === 'readable') {
-        ReadableByteStreamControllerError(controller, e);
-      }
-    })["catch"](rethrowAssertionErrorRejection);
-    return undefined;
-  }
-
-  function ReadableByteStreamControllerClearPendingPullIntos(controller) {
-    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
-    controller._pendingPullIntos = [];
-  }
-
-  function ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor) {
-    assert(stream._state !== 'errored', 'state must not be errored');
-    var done = false;
-
-    if (stream._state === 'closed') {
-      assert(pullIntoDescriptor.bytesFilled === 0);
-      done = true;
-    }
-
-    var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
-
-    if (pullIntoDescriptor.readerType === 'default') {
-      ReadableStreamFulfillReadRequest(stream, filledView, done);
-    } else {
-      assert(pullIntoDescriptor.readerType === 'byob');
-      ReadableStreamFulfillReadIntoRequest(stream, filledView, done);
-    }
-  }
-
-  function ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor) {
-    var bytesFilled = pullIntoDescriptor.bytesFilled;
-    var elementSize = pullIntoDescriptor.elementSize;
-    assert(bytesFilled <= pullIntoDescriptor.byteLength);
-    assert(bytesFilled % elementSize === 0);
-    return new pullIntoDescriptor.ctor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, bytesFilled / elementSize);
-  }
-
-  function ReadableByteStreamControllerEnqueueChunkToQueue(controller, buffer, byteOffset, byteLength) {
-    controller._queue.push({
-      buffer: buffer,
-      byteOffset: byteOffset,
-      byteLength: byteLength
-    });
-
-    controller._queueTotalSize += byteLength;
-  }
-
-  function ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) {
-    var elementSize = pullIntoDescriptor.elementSize;
-    var currentAlignedBytes = pullIntoDescriptor.bytesFilled - pullIntoDescriptor.bytesFilled % elementSize;
-    var maxBytesToCopy = Math.min(controller._queueTotalSize, pullIntoDescriptor.byteLength - pullIntoDescriptor.bytesFilled);
-    var maxBytesFilled = pullIntoDescriptor.bytesFilled + maxBytesToCopy;
-    var maxAlignedBytes = maxBytesFilled - maxBytesFilled % elementSize;
-    var totalBytesToCopyRemaining = maxBytesToCopy;
-    var ready = false;
-
-    if (maxAlignedBytes > currentAlignedBytes) {
-      totalBytesToCopyRemaining = maxAlignedBytes - pullIntoDescriptor.bytesFilled;
-      ready = true;
-    }
-
-    var queue = controller._queue;
-
-    while (totalBytesToCopyRemaining > 0) {
-      var headOfQueue = queue[0];
-      var bytesToCopy = Math.min(totalBytesToCopyRemaining, headOfQueue.byteLength);
-      var destStart = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
-      ArrayBufferCopy(pullIntoDescriptor.buffer, destStart, headOfQueue.buffer, headOfQueue.byteOffset, bytesToCopy);
-
-      if (headOfQueue.byteLength === bytesToCopy) {
-        queue.shift();
-      } else {
-        headOfQueue.byteOffset += bytesToCopy;
-        headOfQueue.byteLength -= bytesToCopy;
-      }
-
-      controller._queueTotalSize -= bytesToCopy;
-      ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesToCopy, pullIntoDescriptor);
-      totalBytesToCopyRemaining -= bytesToCopy;
-    }
-
-    if (ready === false) {
-      assert(controller._queueTotalSize === 0, 'queue must be empty');
-      assert(pullIntoDescriptor.bytesFilled > 0);
-      assert(pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize);
-    }
-
-    return ready;
-  }
-
-  function ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, size, pullIntoDescriptor) {
-    assert(controller._pendingPullIntos.length === 0 || controller._pendingPullIntos[0] === pullIntoDescriptor);
-    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
-    pullIntoDescriptor.bytesFilled += size;
-  }
-
-  function ReadableByteStreamControllerHandleQueueDrain(controller) {
-    assert(controller._controlledReadableStream._state === 'readable');
-
-    if (controller._queueTotalSize === 0 && controller._closeRequested === true) {
-      ReadableStreamClose(controller._controlledReadableStream);
-    } else {
-      ReadableByteStreamControllerCallPullIfNeeded(controller);
-    }
-  }
-
-  function ReadableByteStreamControllerInvalidateBYOBRequest(controller) {
-    if (controller._byobRequest === undefined) {
-      return;
-    }
-
-    controller._byobRequest._associatedReadableByteStreamController = undefined;
-    controller._byobRequest._view = undefined;
-    controller._byobRequest = undefined;
-  }
-
-  function ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller) {
-    assert(controller._closeRequested === false);
-
-    while (controller._pendingPullIntos.length > 0) {
-      if (controller._queueTotalSize === 0) {
-        return;
-      }
-
-      var pullIntoDescriptor = controller._pendingPullIntos[0];
-
-      if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) {
-        ReadableByteStreamControllerShiftPendingPullInto(controller);
-        ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableStream, pullIntoDescriptor);
-      }
-    }
-  }
-
-  function ReadableByteStreamControllerPullInto(controller, view) {
-    var stream = controller._controlledReadableStream;
-    var elementSize = 1;
-
-    if (view.constructor !== DataView) {
-      elementSize = view.constructor.BYTES_PER_ELEMENT;
-    }
-
-    var ctor = view.constructor;
-    var pullIntoDescriptor = {
-      buffer: view.buffer,
-      byteOffset: view.byteOffset,
-      byteLength: view.byteLength,
-      bytesFilled: 0,
-      elementSize: elementSize,
-      ctor: ctor,
-      readerType: 'byob'
-    };
-
-    if (controller._pendingPullIntos.length > 0) {
-      pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer);
-
-      controller._pendingPullIntos.push(pullIntoDescriptor);
-
-      return ReadableStreamAddReadIntoRequest(stream);
-    }
-
-    if (stream._state === 'closed') {
-      var emptyView = new view.constructor(pullIntoDescriptor.buffer, pullIntoDescriptor.byteOffset, 0);
-      return Promise.resolve(CreateIterResultObject(emptyView, true));
-    }
-
-    if (controller._queueTotalSize > 0) {
-      if (ReadableByteStreamControllerFillPullIntoDescriptorFromQueue(controller, pullIntoDescriptor) === true) {
-        var filledView = ReadableByteStreamControllerConvertPullIntoDescriptor(pullIntoDescriptor);
-        ReadableByteStreamControllerHandleQueueDrain(controller);
-        return Promise.resolve(CreateIterResultObject(filledView, false));
-      }
-
-      if (controller._closeRequested === true) {
-        var e = new TypeError('Insufficient bytes to fill elements in the given buffer');
-        ReadableByteStreamControllerError(controller, e);
-        return Promise.reject(e);
-      }
-    }
-
-    pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer);
-
-    controller._pendingPullIntos.push(pullIntoDescriptor);
-
-    var promise = ReadableStreamAddReadIntoRequest(stream);
-    ReadableByteStreamControllerCallPullIfNeeded(controller);
-    return promise;
-  }
-
-  function ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor) {
-    firstDescriptor.buffer = TransferArrayBuffer(firstDescriptor.buffer);
-    assert(firstDescriptor.bytesFilled === 0, 'bytesFilled must be 0');
-    var stream = controller._controlledReadableStream;
-
-    if (ReadableStreamHasBYOBReader(stream) === true) {
-      while (ReadableStreamGetNumReadIntoRequests(stream) > 0) {
-        var pullIntoDescriptor = ReadableByteStreamControllerShiftPendingPullInto(controller);
-        ReadableByteStreamControllerCommitPullIntoDescriptor(stream, pullIntoDescriptor);
-      }
-    }
-  }
-
-  function ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, pullIntoDescriptor) {
-    if (pullIntoDescriptor.bytesFilled + bytesWritten > pullIntoDescriptor.byteLength) {
-      throw new RangeError('bytesWritten out of range');
-    }
-
-    ReadableByteStreamControllerFillHeadPullIntoDescriptor(controller, bytesWritten, pullIntoDescriptor);
-
-    if (pullIntoDescriptor.bytesFilled < pullIntoDescriptor.elementSize) {
-      return;
-    }
-
-    ReadableByteStreamControllerShiftPendingPullInto(controller);
-    var remainderSize = pullIntoDescriptor.bytesFilled % pullIntoDescriptor.elementSize;
-
-    if (remainderSize > 0) {
-      var end = pullIntoDescriptor.byteOffset + pullIntoDescriptor.bytesFilled;
-      var remainder = pullIntoDescriptor.buffer.slice(end - remainderSize, end);
-      ReadableByteStreamControllerEnqueueChunkToQueue(controller, remainder, 0, remainder.byteLength);
-    }
-
-    pullIntoDescriptor.buffer = TransferArrayBuffer(pullIntoDescriptor.buffer);
-    pullIntoDescriptor.bytesFilled -= remainderSize;
-    ReadableByteStreamControllerCommitPullIntoDescriptor(controller._controlledReadableStream, pullIntoDescriptor);
-    ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
-  }
-
-  function ReadableByteStreamControllerRespondInternal(controller, bytesWritten) {
-    var firstDescriptor = controller._pendingPullIntos[0];
-    var stream = controller._controlledReadableStream;
-
-    if (stream._state === 'closed') {
-      if (bytesWritten !== 0) {
-        throw new TypeError('bytesWritten must be 0 when calling respond() on a closed stream');
-      }
-
-      ReadableByteStreamControllerRespondInClosedState(controller, firstDescriptor);
-    } else {
-      assert(stream._state === 'readable');
-      ReadableByteStreamControllerRespondInReadableState(controller, bytesWritten, firstDescriptor);
-    }
-  }
-
-  function ReadableByteStreamControllerShiftPendingPullInto(controller) {
-    var descriptor = controller._pendingPullIntos.shift();
-
-    ReadableByteStreamControllerInvalidateBYOBRequest(controller);
-    return descriptor;
-  }
-
-  function ReadableByteStreamControllerShouldCallPull(controller) {
-    var stream = controller._controlledReadableStream;
-
-    if (stream._state !== 'readable') {
-      return false;
-    }
-
-    if (controller._closeRequested === true) {
-      return false;
-    }
-
-    if (controller._started === false) {
-      return false;
-    }
-
-    if (ReadableStreamHasDefaultReader(stream) === true && ReadableStreamGetNumReadRequests(stream) > 0) {
-      return true;
-    }
-
-    if (ReadableStreamHasBYOBReader(stream) === true && ReadableStreamGetNumReadIntoRequests(stream) > 0) {
-      return true;
-    }
-
-    if (ReadableByteStreamControllerGetDesiredSize(controller) > 0) {
-      return true;
-    }
-
-    return false;
-  }
-
-  function ReadableByteStreamControllerClose(controller) {
-    var stream = controller._controlledReadableStream;
-    assert(controller._closeRequested === false);
-    assert(stream._state === 'readable');
-
-    if (controller._queueTotalSize > 0) {
-      controller._closeRequested = true;
-      return;
-    }
-
-    if (controller._pendingPullIntos.length > 0) {
-      var firstPendingPullInto = controller._pendingPullIntos[0];
-
-      if (firstPendingPullInto.bytesFilled > 0) {
-        var e = new TypeError('Insufficient bytes to fill elements in the given buffer');
-        ReadableByteStreamControllerError(controller, e);
-        throw e;
-      }
-    }
-
-    ReadableStreamClose(stream);
-  }
-
-  function ReadableByteStreamControllerEnqueue(controller, chunk) {
-    var stream = controller._controlledReadableStream;
-    assert(controller._closeRequested === false);
-    assert(stream._state === 'readable');
-    var buffer = chunk.buffer;
-    var byteOffset = chunk.byteOffset;
-    var byteLength = chunk.byteLength;
-    var transferredBuffer = TransferArrayBuffer(buffer);
-
-    if (ReadableStreamHasDefaultReader(stream) === true) {
-      if (ReadableStreamGetNumReadRequests(stream) === 0) {
-        ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
-      } else {
-        assert(controller._queue.length === 0);
-        var transferredView = new Uint8Array(transferredBuffer, byteOffset, byteLength);
-        ReadableStreamFulfillReadRequest(stream, transferredView, false);
-      }
-    } else if (ReadableStreamHasBYOBReader(stream) === true) {
-      ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
-      ReadableByteStreamControllerProcessPullIntoDescriptorsUsingQueue(controller);
-    } else {
-      assert(IsReadableStreamLocked(stream) === false, 'stream must not be locked');
-      ReadableByteStreamControllerEnqueueChunkToQueue(controller, transferredBuffer, byteOffset, byteLength);
-    }
-  }
-
-  function ReadableByteStreamControllerError(controller, e) {
-    var stream = controller._controlledReadableStream;
-    assert(stream._state === 'readable');
-    ReadableByteStreamControllerClearPendingPullIntos(controller);
-    ResetQueue(controller);
-    ReadableStreamError(stream, e);
-  }
-
-  function ReadableByteStreamControllerGetDesiredSize(controller) {
-    var stream = controller._controlledReadableStream;
-    var state = stream._state;
-
-    if (state === 'errored') {
-      return null;
-    }
-
-    if (state === 'closed') {
-      return 0;
-    }
-
-    return controller._strategyHWM - controller._queueTotalSize;
-  }
-
-  function ReadableByteStreamControllerRespond(controller, bytesWritten) {
-    bytesWritten = Number(bytesWritten);
-
-    if (IsFiniteNonNegativeNumber(bytesWritten) === false) {
-      throw new RangeError('bytesWritten must be a finite');
-    }
-
-    assert(controller._pendingPullIntos.length > 0);
-    ReadableByteStreamControllerRespondInternal(controller, bytesWritten);
-  }
-
-  function ReadableByteStreamControllerRespondWithNewView(controller, view) {
-    assert(controller._pendingPullIntos.length > 0);
-    var firstDescriptor = controller._pendingPullIntos[0];
-
-    if (firstDescriptor.byteOffset + firstDescriptor.bytesFilled !== view.byteOffset) {
-      throw new RangeError('The region specified by view does not match byobRequest');
-    }
-
-    if (firstDescriptor.byteLength !== view.byteLength) {
-      throw new RangeError('The buffer of view has different capacity than byobRequest');
-    }
-
-    firstDescriptor.buffer = view.buffer;
-    ReadableByteStreamControllerRespondInternal(controller, view.byteLength);
-  }
-
-  function streamBrandCheckException(name) {
-    return new TypeError('ReadableStream.prototype.' + name + ' can only be used on a ReadableStream');
-  }
-
-  function readerLockException(name) {
-    return new TypeError('Cannot ' + name + ' a stream using a released reader');
-  }
-
-  function defaultReaderBrandCheckException(name) {
-    return new TypeError('ReadableStreamDefaultReader.prototype.' + name + ' can only be used on a ReadableStreamDefaultReader');
-  }
-
-  function defaultReaderClosedPromiseInitialize(reader) {
-    reader._closedPromise = new Promise(function (resolve, reject) {
-      reader._closedPromise_resolve = resolve;
-      reader._closedPromise_reject = reject;
-    });
-  }
-
-  function defaultReaderClosedPromiseInitializeAsRejected(reader, reason) {
-    reader._closedPromise = Promise.reject(reason);
-    reader._closedPromise_resolve = undefined;
-    reader._closedPromise_reject = undefined;
-  }
-
-  function defaultReaderClosedPromiseInitializeAsResolved(reader) {
-    reader._closedPromise = Promise.resolve(undefined);
-    reader._closedPromise_resolve = undefined;
-    reader._closedPromise_reject = undefined;
-  }
-
-  function defaultReaderClosedPromiseReject(reader, reason) {
-    assert(reader._closedPromise_resolve !== undefined);
-    assert(reader._closedPromise_reject !== undefined);
-
-    reader._closedPromise_reject(reason);
-
-    reader._closedPromise_resolve = undefined;
-    reader._closedPromise_reject = undefined;
-  }
-
-  function defaultReaderClosedPromiseResetToRejected(reader, reason) {
-    assert(reader._closedPromise_resolve === undefined);
-    assert(reader._closedPromise_reject === undefined);
-    reader._closedPromise = Promise.reject(reason);
-  }
-
-  function defaultReaderClosedPromiseResolve(reader) {
-    assert(reader._closedPromise_resolve !== undefined);
-    assert(reader._closedPromise_reject !== undefined);
-
-    reader._closedPromise_resolve(undefined);
-
-    reader._closedPromise_resolve = undefined;
-    reader._closedPromise_reject = undefined;
-  }
-
-  function byobReaderBrandCheckException(name) {
-    return new TypeError('ReadableStreamBYOBReader.prototype.' + name + ' can only be used on a ReadableStreamBYOBReader');
-  }
-
-  function defaultControllerBrandCheckException(name) {
-    return new TypeError('ReadableStreamDefaultController.prototype.' + name + ' can only be used on a ReadableStreamDefaultController');
-  }
-
-  function byobRequestBrandCheckException(name) {
-    return new TypeError('ReadableStreamBYOBRequest.prototype.' + name + ' can only be used on a ReadableStreamBYOBRequest');
-  }
-
-  function byteStreamControllerBrandCheckException(name) {
-    return new TypeError('ReadableByteStreamController.prototype.' + name + ' can only be used on a ReadableByteStreamController');
-  }
-
-  function ifIsObjectAndHasAPromiseIsHandledInternalSlotSetPromiseIsHandledToTrue(promise) {
-    try {
-      Promise.prototype.then.call(promise, undefined, function () {});
-    } catch (e) {}
-  }
-}, function (module, exports, __w_pdfjs_require__) {
-  "use strict";
-
-  var transformStream = __w_pdfjs_require__(6);
-
-  var readableStream = __w_pdfjs_require__(4);
-
-  var writableStream = __w_pdfjs_require__(2);
-
-  exports.TransformStream = transformStream.TransformStream;
-  exports.ReadableStream = readableStream.ReadableStream;
-  exports.IsReadableStreamDisturbed = readableStream.IsReadableStreamDisturbed;
-  exports.ReadableStreamDefaultControllerClose = readableStream.ReadableStreamDefaultControllerClose;
-  exports.ReadableStreamDefaultControllerEnqueue = readableStream.ReadableStreamDefaultControllerEnqueue;
-  exports.ReadableStreamDefaultControllerError = readableStream.ReadableStreamDefaultControllerError;
-  exports.ReadableStreamDefaultControllerGetDesiredSize = readableStream.ReadableStreamDefaultControllerGetDesiredSize;
-  exports.AcquireWritableStreamDefaultWriter = writableStream.AcquireWritableStreamDefaultWriter;
-  exports.IsWritableStream = writableStream.IsWritableStream;
-  exports.IsWritableStreamLocked = writableStream.IsWritableStreamLocked;
-  exports.WritableStream = writableStream.WritableStream;
-  exports.WritableStreamAbort = writableStream.WritableStreamAbort;
-  exports.WritableStreamDefaultControllerError = writableStream.WritableStreamDefaultControllerError;
-  exports.WritableStreamDefaultWriterCloseWithErrorPropagation = writableStream.WritableStreamDefaultWriterCloseWithErrorPropagation;
-  exports.WritableStreamDefaultWriterRelease = writableStream.WritableStreamDefaultWriterRelease;
-  exports.WritableStreamDefaultWriterWrite = writableStream.WritableStreamDefaultWriterWrite;
-}, function (module, exports, __w_pdfjs_require__) {
-  "use strict";
-
-  var _createClass = function () {
-    function defineProperties(target, props) {
-      for (var i = 0; i < props.length; i++) {
-        var descriptor = props[i];
-        descriptor.enumerable = descriptor.enumerable || false;
-        descriptor.configurable = true;
-        if ("value" in descriptor) descriptor.writable = true;
-        Object.defineProperty(target, descriptor.key, descriptor);
-      }
-    }
-
-    return function (Constructor, protoProps, staticProps) {
-      if (protoProps) defineProperties(Constructor.prototype, protoProps);
-      if (staticProps) defineProperties(Constructor, staticProps);
-      return Constructor;
-    };
-  }();
-
-  function _classCallCheck(instance, Constructor) {
-    if (!(instance instanceof Constructor)) {
-      throw new TypeError("Cannot call a class as a function");
-    }
-  }
-
-  var _require = __w_pdfjs_require__(1),
-      assert = _require.assert;
-
-  var _require2 = __w_pdfjs_require__(0),
-      InvokeOrNoop = _require2.InvokeOrNoop,
-      PromiseInvokeOrPerformFallback = _require2.PromiseInvokeOrPerformFallback,
-      PromiseInvokeOrNoop = _require2.PromiseInvokeOrNoop,
-      typeIsObject = _require2.typeIsObject;
-
-  var _require3 = __w_pdfjs_require__(4),
-      ReadableStream = _require3.ReadableStream,
-      ReadableStreamDefaultControllerClose = _require3.ReadableStreamDefaultControllerClose,
-      ReadableStreamDefaultControllerEnqueue = _require3.ReadableStreamDefaultControllerEnqueue,
-      ReadableStreamDefaultControllerError = _require3.ReadableStreamDefaultControllerError,
-      ReadableStreamDefaultControllerGetDesiredSize = _require3.ReadableStreamDefaultControllerGetDesiredSize;
-
-  var _require4 = __w_pdfjs_require__(2),
-      WritableStream = _require4.WritableStream,
-      WritableStreamDefaultControllerError = _require4.WritableStreamDefaultControllerError;
-
-  function TransformStreamCloseReadable(transformStream) {
-    if (transformStream._errored === true) {
-      throw new TypeError('TransformStream is already errored');
-    }
-
-    if (transformStream._readableClosed === true) {
-      throw new TypeError('Readable side is already closed');
-    }
-
-    TransformStreamCloseReadableInternal(transformStream);
-  }
-
-  function TransformStreamEnqueueToReadable(transformStream, chunk) {
-    if (transformStream._errored === true) {
-      throw new TypeError('TransformStream is already errored');
-    }
-
-    if (transformStream._readableClosed === true) {
-      throw new TypeError('Readable side is already closed');
-    }
-
-    var controller = transformStream._readableController;
-
-    try {
-      ReadableStreamDefaultControllerEnqueue(controller, chunk);
-    } catch (e) {
-      transformStream._readableClosed = true;
-      TransformStreamErrorIfNeeded(transformStream, e);
-      throw transformStream._storedError;
-    }
-
-    var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(controller);
-    var maybeBackpressure = desiredSize <= 0;
-
-    if (maybeBackpressure === true && transformStream._backpressure === false) {
-      TransformStreamSetBackpressure(transformStream, true);
-    }
-  }
-
-  function TransformStreamError(transformStream, e) {
-    if (transformStream._errored === true) {
-      throw new TypeError('TransformStream is already errored');
-    }
-
-    TransformStreamErrorInternal(transformStream, e);
-  }
-
-  function TransformStreamCloseReadableInternal(transformStream) {
-    assert(transformStream._errored === false);
-    assert(transformStream._readableClosed === false);
-
-    try {
-      ReadableStreamDefaultControllerClose(transformStream._readableController);
-    } catch (e) {
-      assert(false);
-    }
-
-    transformStream._readableClosed = true;
-  }
-
-  function TransformStreamErrorIfNeeded(transformStream, e) {
-    if (transformStream._errored === false) {
-      TransformStreamErrorInternal(transformStream, e);
-    }
-  }
-
-  function TransformStreamErrorInternal(transformStream, e) {
-    assert(transformStream._errored === false);
-    transformStream._errored = true;
-    transformStream._storedError = e;
-
-    if (transformStream._writableDone === false) {
-      WritableStreamDefaultControllerError(transformStream._writableController, e);
-    }
-
-    if (transformStream._readableClosed === false) {
-      ReadableStreamDefaultControllerError(transformStream._readableController, e);
-    }
-  }
-
-  function TransformStreamReadableReadyPromise(transformStream) {
-    assert(transformStream._backpressureChangePromise !== undefined, '_backpressureChangePromise should have been initialized');
-
-    if (transformStream._backpressure === false) {
-      return Promise.resolve();
-    }
-
-    assert(transformStream._backpressure === true, '_backpressure should have been initialized');
-    return transformStream._backpressureChangePromise;
-  }
-
-  function TransformStreamSetBackpressure(transformStream, backpressure) {
-    assert(transformStream._backpressure !== backpressure, 'TransformStreamSetBackpressure() should be called only when backpressure is changed');
-
-    if (transformStream._backpressureChangePromise !== undefined) {
-      transformStream._backpressureChangePromise_resolve(backpressure);
-    }
-
-    transformStream._backpressureChangePromise = new Promise(function (resolve) {
-      transformStream._backpressureChangePromise_resolve = resolve;
-    });
-
-    transformStream._backpressureChangePromise.then(function (resolution) {
-      assert(resolution !== backpressure, '_backpressureChangePromise should be fulfilled only when backpressure is changed');
-    });
-
-    transformStream._backpressure = backpressure;
-  }
-
-  function TransformStreamDefaultTransform(chunk, transformStreamController) {
-    var transformStream = transformStreamController._controlledTransformStream;
-    TransformStreamEnqueueToReadable(transformStream, chunk);
-    return Promise.resolve();
-  }
-
-  function TransformStreamTransform(transformStream, chunk) {
-    assert(transformStream._errored === false);
-    assert(transformStream._transforming === false);
-    assert(transformStream._backpressure === false);
-    transformStream._transforming = true;
-    var transformer = transformStream._transformer;
-    var controller = transformStream._transformStreamController;
-    var transformPromise = PromiseInvokeOrPerformFallback(transformer, 'transform', [chunk, controller], TransformStreamDefaultTransform, [chunk, controller]);
-    return transformPromise.then(function () {
-      transformStream._transforming = false;
-      return TransformStreamReadableReadyPromise(transformStream);
-    }, function (e) {
-      TransformStreamErrorIfNeeded(transformStream, e);
-      return Promise.reject(e);
-    });
-  }
-
-  function IsTransformStreamDefaultController(x) {
-    if (!typeIsObject(x)) {
-      return false;
-    }
-
-    if (!Object.prototype.hasOwnProperty.call(x, '_controlledTransformStream')) {
-      return false;
-    }
-
-    return true;
-  }
-
-  function IsTransformStream(x) {
-    if (!typeIsObject(x)) {
-      return false;
-    }
-
-    if (!Object.prototype.hasOwnProperty.call(x, '_transformStreamController')) {
-      return false;
-    }
-
-    return true;
-  }
-
-  var TransformStreamSink = function () {
-    function TransformStreamSink(transformStream, startPromise) {
-      _classCallCheck(this, TransformStreamSink);
-
-      this._transformStream = transformStream;
-      this._startPromise = startPromise;
-    }
-
-    _createClass(TransformStreamSink, [{
-      key: 'start',
-      value: function start(c) {
-        var transformStream = this._transformStream;
-        transformStream._writableController = c;
-        return this._startPromise.then(function () {
-          return TransformStreamReadableReadyPromise(transformStream);
-        });
-      }
-    }, {
-      key: 'write',
-      value: function write(chunk) {
-        var transformStream = this._transformStream;
-        return TransformStreamTransform(transformStream, chunk);
-      }
-    }, {
-      key: 'abort',
-      value: function abort() {
-        var transformStream = this._transformStream;
-        transformStream._writableDone = true;
-        TransformStreamErrorInternal(transformStream, new TypeError('Writable side aborted'));
-      }
-    }, {
-      key: 'close',
-      value: function close() {
-        var transformStream = this._transformStream;
-        assert(transformStream._transforming === false);
-        transformStream._writableDone = true;
-        var flushPromise = PromiseInvokeOrNoop(transformStream._transformer, 'flush', [transformStream._transformStreamController]);
-        return flushPromise.then(function () {
-          if (transformStream._errored === true) {
-            return Promise.reject(transformStream._storedError);
-          }
-
-          if (transformStream._readableClosed === false) {
-            TransformStreamCloseReadableInternal(transformStream);
-          }
-
-          return Promise.resolve();
-        })["catch"](function (r) {
-          TransformStreamErrorIfNeeded(transformStream, r);
-          return Promise.reject(transformStream._storedError);
-        });
-      }
-    }]);
-
-    return TransformStreamSink;
-  }();
-
-  var TransformStreamSource = function () {
-    function TransformStreamSource(transformStream, startPromise) {
-      _classCallCheck(this, TransformStreamSource);
-
-      this._transformStream = transformStream;
-      this._startPromise = startPromise;
-    }
-
-    _createClass(TransformStreamSource, [{
-      key: 'start',
-      value: function start(c) {
-        var transformStream = this._transformStream;
-        transformStream._readableController = c;
-        return this._startPromise.then(function () {
-          assert(transformStream._backpressureChangePromise !== undefined, '_backpressureChangePromise should have been initialized');
-
-          if (transformStream._backpressure === true) {
-            return Promise.resolve();
-          }
-
-          assert(transformStream._backpressure === false, '_backpressure should have been initialized');
-          return transformStream._backpressureChangePromise;
-        });
-      }
-    }, {
-      key: 'pull',
-      value: function pull() {
-        var transformStream = this._transformStream;
-        assert(transformStream._backpressure === true, 'pull() should be never called while _backpressure is false');
-        assert(transformStream._backpressureChangePromise !== undefined, '_backpressureChangePromise should have been initialized');
-        TransformStreamSetBackpressure(transformStream, false);
-        return transformStream._backpressureChangePromise;
-      }
-    }, {
-      key: 'cancel',
-      value: function cancel() {
-        var transformStream = this._transformStream;
-        transformStream._readableClosed = true;
-        TransformStreamErrorInternal(transformStream, new TypeError('Readable side canceled'));
-      }
-    }]);
-
-    return TransformStreamSource;
-  }();
-
-  var TransformStreamDefaultController = function () {
-    function TransformStreamDefaultController(transformStream) {
-      _classCallCheck(this, TransformStreamDefaultController);
-
-      if (IsTransformStream(transformStream) === false) {
-        throw new TypeError('TransformStreamDefaultController can only be ' + 'constructed with a TransformStream instance');
-      }
-
-      if (transformStream._transformStreamController !== undefined) {
-        throw new TypeError('TransformStreamDefaultController instances can ' + 'only be created by the TransformStream constructor');
-      }
-
-      this._controlledTransformStream = transformStream;
-    }
-
-    _createClass(TransformStreamDefaultController, [{
-      key: 'enqueue',
-      value: function enqueue(chunk) {
-        if (IsTransformStreamDefaultController(this) === false) {
-          throw defaultControllerBrandCheckException('enqueue');
-        }
-
-        TransformStreamEnqueueToReadable(this._controlledTransformStream, chunk);
-      }
-    }, {
-      key: 'close',
-      value: function close() {
-        if (IsTransformStreamDefaultController(this) === false) {
-          throw defaultControllerBrandCheckException('close');
-        }
-
-        TransformStreamCloseReadable(this._controlledTransformStream);
-      }
-    }, {
-      key: 'error',
-      value: function error(reason) {
-        if (IsTransformStreamDefaultController(this) === false) {
-          throw defaultControllerBrandCheckException('error');
-        }
-
-        TransformStreamError(this._controlledTransformStream, reason);
-      }
-    }, {
-      key: 'desiredSize',
-      get: function get() {
-        if (IsTransformStreamDefaultController(this) === false) {
-          throw defaultControllerBrandCheckException('desiredSize');
-        }
-
-        var transformStream = this._controlledTransformStream;
-        var readableController = transformStream._readableController;
-        return ReadableStreamDefaultControllerGetDesiredSize(readableController);
-      }
-    }]);
-
-    return TransformStreamDefaultController;
-  }();
-
-  var TransformStream = function () {
-    function TransformStream() {
-      var transformer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
-      _classCallCheck(this, TransformStream);
-
-      this._transformer = transformer;
-      var readableStrategy = transformer.readableStrategy,
-          writableStrategy = transformer.writableStrategy;
-      this._transforming = false;
-      this._errored = false;
-      this._storedError = undefined;
-      this._writableController = undefined;
-      this._readableController = undefined;
-      this._transformStreamController = undefined;
-      this._writableDone = false;
-      this._readableClosed = false;
-      this._backpressure = undefined;
-      this._backpressureChangePromise = undefined;
-      this._backpressureChangePromise_resolve = undefined;
-      this._transformStreamController = new TransformStreamDefaultController(this);
-      var startPromise_resolve = void 0;
-      var startPromise = new Promise(function (resolve) {
-        startPromise_resolve = resolve;
-      });
-      var source = new TransformStreamSource(this, startPromise);
-      this._readable = new ReadableStream(source, readableStrategy);
-      var sink = new TransformStreamSink(this, startPromise);
-      this._writable = new WritableStream(sink, writableStrategy);
-      assert(this._writableController !== undefined);
-      assert(this._readableController !== undefined);
-      var desiredSize = ReadableStreamDefaultControllerGetDesiredSize(this._readableController);
-      TransformStreamSetBackpressure(this, desiredSize <= 0);
-      var transformStream = this;
-      var startResult = InvokeOrNoop(transformer, 'start', [transformStream._transformStreamController]);
-      startPromise_resolve(startResult);
-      startPromise["catch"](function (e) {
-        if (transformStream._errored === false) {
-          transformStream._errored = true;
-          transformStream._storedError = e;
-        }
-      });
-    }
-
-    _createClass(TransformStream, [{
-      key: 'readable',
-      get: function get() {
-        if (IsTransformStream(this) === false) {
-          throw streamBrandCheckException('readable');
-        }
-
-        return this._readable;
-      }
-    }, {
-      key: 'writable',
-      get: function get() {
-        if (IsTransformStream(this) === false) {
-          throw streamBrandCheckException('writable');
-        }
-
-        return this._writable;
-      }
-    }]);
-
-    return TransformStream;
-  }();
-
-  module.exports = {
-    TransformStream: TransformStream
-  };
-
-  function defaultControllerBrandCheckException(name) {
-    return new TypeError('TransformStreamDefaultController.prototype.' + name + ' can only be used on a TransformStreamDefaultController');
-  }
-
-  function streamBrandCheckException(name) {
-    return new TypeError('TransformStream.prototype.' + name + ' can only be used on a TransformStream');
-  }
-}, function (module, exports, __w_pdfjs_require__) {
-  module.exports = __w_pdfjs_require__(5);
-}]));
-
-/***/ }),
-/* 145 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-{
-  var isURLSupported = false;
-
-  try {
-    if (typeof URL === 'function' && _typeof(URL.prototype) === 'object' && 'origin' in URL.prototype) {
-      var u = new URL('b', 'http://a');
-      u.pathname = 'c%20d';
-      isURLSupported = u.href === 'http://a/c%20d';
-    }
-  } catch (ex) {}
-
-  if (isURLSupported) {
-    exports.URL = URL;
-  } else {
-    var PolyfillURL = __w_pdfjs_require__(146).URL;
-
-    var OriginalURL = __w_pdfjs_require__(3).URL;
-
-    if (OriginalURL) {
-      PolyfillURL.createObjectURL = function (blob) {
-        return OriginalURL.createObjectURL.apply(OriginalURL, arguments);
-      };
-
-      PolyfillURL.revokeObjectURL = function (url) {
-        OriginalURL.revokeObjectURL(url);
-      };
-    }
-
-    exports.URL = PolyfillURL;
-  }
-}
-
-/***/ }),
-/* 146 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-(function URLConstructorClosure() {
-  'use strict';
-
-  var relative = Object.create(null);
-  relative['ftp'] = 21;
-  relative['file'] = 0;
-  relative['gopher'] = 70;
-  relative['http'] = 80;
-  relative['https'] = 443;
-  relative['ws'] = 80;
-  relative['wss'] = 443;
-  var relativePathDotMapping = Object.create(null);
-  relativePathDotMapping['%2e'] = '.';
-  relativePathDotMapping['.%2e'] = '..';
-  relativePathDotMapping['%2e.'] = '..';
-  relativePathDotMapping['%2e%2e'] = '..';
-
-  function isRelativeScheme(scheme) {
-    return relative[scheme] !== undefined;
-  }
-
-  function invalid() {
-    clear.call(this);
-    this._isInvalid = true;
-  }
-
-  function IDNAToASCII(h) {
-    if (h === '') {
-      invalid.call(this);
-    }
-
-    return h.toLowerCase();
-  }
-
-  function percentEscape(c) {
-    var unicode = c.charCodeAt(0);
-
-    if (unicode > 0x20 && unicode < 0x7F && [0x22, 0x23, 0x3C, 0x3E, 0x3F, 0x60].indexOf(unicode) === -1) {
-      return c;
-    }
-
-    return encodeURIComponent(c);
-  }
-
-  function percentEscapeQuery(c) {
-    var unicode = c.charCodeAt(0);
-
-    if (unicode > 0x20 && unicode < 0x7F && [0x22, 0x23, 0x3C, 0x3E, 0x60].indexOf(unicode) === -1) {
-      return c;
-    }
-
-    return encodeURIComponent(c);
-  }
-
-  var EOF,
-      ALPHA = /[a-zA-Z]/,
-      ALPHANUMERIC = /[a-zA-Z0-9\+\-\.]/;
-
-  function parse(input, stateOverride, base) {
-    function err(message) {
-      errors.push(message);
-    }
-
-    var state = stateOverride || 'scheme start',
-        cursor = 0,
-        buffer = '',
-        seenAt = false,
-        seenBracket = false,
-        errors = [];
-
-    loop: while ((input[cursor - 1] !== EOF || cursor === 0) && !this._isInvalid) {
-      var c = input[cursor];
-
-      switch (state) {
-        case 'scheme start':
-          if (c && ALPHA.test(c)) {
-            buffer += c.toLowerCase();
-            state = 'scheme';
-          } else if (!stateOverride) {
-            buffer = '';
-            state = 'no scheme';
-            continue;
-          } else {
-            err('Invalid scheme.');
-            break loop;
-          }
-
-          break;
-
-        case 'scheme':
-          if (c && ALPHANUMERIC.test(c)) {
-            buffer += c.toLowerCase();
-          } else if (c === ':') {
-            this._scheme = buffer;
-            buffer = '';
-
-            if (stateOverride) {
-              break loop;
-            }
-
-            if (isRelativeScheme(this._scheme)) {
-              this._isRelative = true;
-            }
-
-            if (this._scheme === 'file') {
-              state = 'relative';
-            } else if (this._isRelative && base && base._scheme === this._scheme) {
-              state = 'relative or authority';
-            } else if (this._isRelative) {
-              state = 'authority first slash';
-            } else {
-              state = 'scheme data';
-            }
-          } else if (!stateOverride) {
-            buffer = '';
-            cursor = 0;
-            state = 'no scheme';
-            continue;
-          } else if (c === EOF) {
-            break loop;
-          } else {
-            err('Code point not allowed in scheme: ' + c);
-            break loop;
-          }
-
-          break;
-
-        case 'scheme data':
-          if (c === '?') {
-            this._query = '?';
-            state = 'query';
-          } else if (c === '#') {
-            this._fragment = '#';
-            state = 'fragment';
-          } else {
-            if (c !== EOF && c !== '\t' && c !== '\n' && c !== '\r') {
-              this._schemeData += percentEscape(c);
-            }
-          }
-
-          break;
-
-        case 'no scheme':
-          if (!base || !isRelativeScheme(base._scheme)) {
-            err('Missing scheme.');
-            invalid.call(this);
-          } else {
-            state = 'relative';
-            continue;
-          }
-
-          break;
-
-        case 'relative or authority':
-          if (c === '/' && input[cursor + 1] === '/') {
-            state = 'authority ignore slashes';
-          } else {
-            err('Expected /, got: ' + c);
-            state = 'relative';
-            continue;
-          }
-
-          break;
-
-        case 'relative':
-          this._isRelative = true;
-
-          if (this._scheme !== 'file') {
-            this._scheme = base._scheme;
-          }
-
-          if (c === EOF) {
-            this._host = base._host;
-            this._port = base._port;
-            this._path = base._path.slice();
-            this._query = base._query;
-            this._username = base._username;
-            this._password = base._password;
-            break loop;
-          } else if (c === '/' || c === '\\') {
-            if (c === '\\') {
-              err('\\ is an invalid code point.');
-            }
-
-            state = 'relative slash';
-          } else if (c === '?') {
-            this._host = base._host;
-            this._port = base._port;
-            this._path = base._path.slice();
-            this._query = '?';
-            this._username = base._username;
-            this._password = base._password;
-            state = 'query';
-          } else if (c === '#') {
-            this._host = base._host;
-            this._port = base._port;
-            this._path = base._path.slice();
-            this._query = base._query;
-            this._fragment = '#';
-            this._username = base._username;
-            this._password = base._password;
-            state = 'fragment';
-          } else {
-            var nextC = input[cursor + 1];
-            var nextNextC = input[cursor + 2];
-
-            if (this._scheme !== 'file' || !ALPHA.test(c) || nextC !== ':' && nextC !== '|' || nextNextC !== EOF && nextNextC !== '/' && nextNextC !== '\\' && nextNextC !== '?' && nextNextC !== '#') {
-              this._host = base._host;
-              this._port = base._port;
-              this._username = base._username;
-              this._password = base._password;
-              this._path = base._path.slice();
-
-              this._path.pop();
-            }
-
-            state = 'relative path';
-            continue;
-          }
-
-          break;
-
-        case 'relative slash':
-          if (c === '/' || c === '\\') {
-            if (c === '\\') {
-              err('\\ is an invalid code point.');
-            }
-
-            if (this._scheme === 'file') {
-              state = 'file host';
-            } else {
-              state = 'authority ignore slashes';
-            }
-          } else {
-            if (this._scheme !== 'file') {
-              this._host = base._host;
-              this._port = base._port;
-              this._username = base._username;
-              this._password = base._password;
-            }
-
-            state = 'relative path';
-            continue;
-          }
-
-          break;
-
-        case 'authority first slash':
-          if (c === '/') {
-            state = 'authority second slash';
-          } else {
-            err('Expected \'/\', got: ' + c);
-            state = 'authority ignore slashes';
-            continue;
-          }
-
-          break;
-
-        case 'authority second slash':
-          state = 'authority ignore slashes';
-
-          if (c !== '/') {
-            err('Expected \'/\', got: ' + c);
-            continue;
-          }
-
-          break;
-
-        case 'authority ignore slashes':
-          if (c !== '/' && c !== '\\') {
-            state = 'authority';
-            continue;
-          } else {
-            err('Expected authority, got: ' + c);
-          }
-
-          break;
-
-        case 'authority':
-          if (c === '@') {
-            if (seenAt) {
-              err('@ already seen.');
-              buffer += '%40';
-            }
-
-            seenAt = true;
-
-            for (var i = 0; i < buffer.length; i++) {
-              var cp = buffer[i];
-
-              if (cp === '\t' || cp === '\n' || cp === '\r') {
-                err('Invalid whitespace in authority.');
-                continue;
-              }
-
-              if (cp === ':' && this._password === null) {
-                this._password = '';
-                continue;
-              }
-
-              var tempC = percentEscape(cp);
-
-              if (this._password !== null) {
-                this._password += tempC;
-              } else {
-                this._username += tempC;
-              }
-            }
-
-            buffer = '';
-          } else if (c === EOF || c === '/' || c === '\\' || c === '?' || c === '#') {
-            cursor -= buffer.length;
-            buffer = '';
-            state = 'host';
-            continue;
-          } else {
-            buffer += c;
-          }
-
-          break;
-
-        case 'file host':
-          if (c === EOF || c === '/' || c === '\\' || c === '?' || c === '#') {
-            if (buffer.length === 2 && ALPHA.test(buffer[0]) && (buffer[1] === ':' || buffer[1] === '|')) {
-              state = 'relative path';
-            } else if (buffer.length === 0) {
-              state = 'relative path start';
-            } else {
-              this._host = IDNAToASCII.call(this, buffer);
-              buffer = '';
-              state = 'relative path start';
-            }
-
-            continue;
-          } else if (c === '\t' || c === '\n' || c === '\r') {
-            err('Invalid whitespace in file host.');
-          } else {
-            buffer += c;
-          }
-
-          break;
-
-        case 'host':
-        case 'hostname':
-          if (c === ':' && !seenBracket) {
-            this._host = IDNAToASCII.call(this, buffer);
-            buffer = '';
-            state = 'port';
-
-            if (stateOverride === 'hostname') {
-              break loop;
-            }
-          } else if (c === EOF || c === '/' || c === '\\' || c === '?' || c === '#') {
-            this._host = IDNAToASCII.call(this, buffer);
-            buffer = '';
-            state = 'relative path start';
-
-            if (stateOverride) {
-              break loop;
-            }
-
-            continue;
-          } else if (c !== '\t' && c !== '\n' && c !== '\r') {
-            if (c === '[') {
-              seenBracket = true;
-            } else if (c === ']') {
-              seenBracket = false;
-            }
-
-            buffer += c;
-          } else {
-            err('Invalid code point in host/hostname: ' + c);
-          }
-
-          break;
-
-        case 'port':
-          if (/[0-9]/.test(c)) {
-            buffer += c;
-          } else if (c === EOF || c === '/' || c === '\\' || c === '?' || c === '#' || stateOverride) {
-            if (buffer !== '') {
-              var temp = parseInt(buffer, 10);
-
-              if (temp !== relative[this._scheme]) {
-                this._port = temp + '';
-              }
-
-              buffer = '';
-            }
-
-            if (stateOverride) {
-              break loop;
-            }
-
-            state = 'relative path start';
-            continue;
-          } else if (c === '\t' || c === '\n' || c === '\r') {
-            err('Invalid code point in port: ' + c);
-          } else {
-            invalid.call(this);
-          }
-
-          break;
-
-        case 'relative path start':
-          if (c === '\\') {
-            err('\'\\\' not allowed in path.');
-          }
-
-          state = 'relative path';
-
-          if (c !== '/' && c !== '\\') {
-            continue;
-          }
-
-          break;
-
-        case 'relative path':
-          if (c === EOF || c === '/' || c === '\\' || !stateOverride && (c === '?' || c === '#')) {
-            if (c === '\\') {
-              err('\\ not allowed in relative path.');
-            }
-
-            var tmp;
-
-            if (tmp = relativePathDotMapping[buffer.toLowerCase()]) {
-              buffer = tmp;
-            }
-
-            if (buffer === '..') {
-              this._path.pop();
-
-              if (c !== '/' && c !== '\\') {
-                this._path.push('');
-              }
-            } else if (buffer === '.' && c !== '/' && c !== '\\') {
-              this._path.push('');
-            } else if (buffer !== '.') {
-              if (this._scheme === 'file' && this._path.length === 0 && buffer.length === 2 && ALPHA.test(buffer[0]) && buffer[1] === '|') {
-                buffer = buffer[0] + ':';
-              }
-
-              this._path.push(buffer);
-            }
-
-            buffer = '';
-
-            if (c === '?') {
-              this._query = '?';
-              state = 'query';
-            } else if (c === '#') {
-              this._fragment = '#';
-              state = 'fragment';
-            }
-          } else if (c !== '\t' && c !== '\n' && c !== '\r') {
-            buffer += percentEscape(c);
-          }
-
-          break;
-
-        case 'query':
-          if (!stateOverride && c === '#') {
-            this._fragment = '#';
-            state = 'fragment';
-          } else if (c !== EOF && c !== '\t' && c !== '\n' && c !== '\r') {
-            this._query += percentEscapeQuery(c);
-          }
-
-          break;
-
-        case 'fragment':
-          if (c !== EOF && c !== '\t' && c !== '\n' && c !== '\r') {
-            this._fragment += c;
-          }
-
-          break;
-      }
-
-      cursor++;
-    }
-  }
-
-  function clear() {
-    this._scheme = '';
-    this._schemeData = '';
-    this._username = '';
-    this._password = null;
-    this._host = '';
-    this._port = '';
-    this._path = [];
-    this._query = '';
-    this._fragment = '';
-    this._isInvalid = false;
-    this._isRelative = false;
-  }
-
-  function JURL(url, base) {
-    if (base !== undefined && !(base instanceof JURL)) {
-      base = new JURL(String(base));
-    }
-
-    this._url = url;
-    clear.call(this);
-    var input = url.replace(/^[ \t\r\n\f]+|[ \t\r\n\f]+$/g, '');
-    parse.call(this, input, null, base);
-  }
-
-  JURL.prototype = {
-    toString: function toString() {
-      return this.href;
-    },
-
-    get href() {
-      if (this._isInvalid) {
-        return this._url;
-      }
-
-      var authority = '';
-
-      if (this._username !== '' || this._password !== null) {
-        authority = this._username + (this._password !== null ? ':' + this._password : '') + '@';
-      }
-
-      return this.protocol + (this._isRelative ? '//' + authority + this.host : '') + this.pathname + this._query + this._fragment;
-    },
-
-    set href(value) {
-      clear.call(this);
-      parse.call(this, value);
-    },
-
-    get protocol() {
-      return this._scheme + ':';
-    },
-
-    set protocol(value) {
-      if (this._isInvalid) {
-        return;
-      }
-
-      parse.call(this, value + ':', 'scheme start');
-    },
-
-    get host() {
-      return this._isInvalid ? '' : this._port ? this._host + ':' + this._port : this._host;
-    },
-
-    set host(value) {
-      if (this._isInvalid || !this._isRelative) {
-        return;
-      }
-
-      parse.call(this, value, 'host');
-    },
-
-    get hostname() {
-      return this._host;
-    },
-
-    set hostname(value) {
-      if (this._isInvalid || !this._isRelative) {
-        return;
-      }
-
-      parse.call(this, value, 'hostname');
-    },
-
-    get port() {
-      return this._port;
-    },
-
-    set port(value) {
-      if (this._isInvalid || !this._isRelative) {
-        return;
-      }
-
-      parse.call(this, value, 'port');
-    },
-
-    get pathname() {
-      return this._isInvalid ? '' : this._isRelative ? '/' + this._path.join('/') : this._schemeData;
-    },
-
-    set pathname(value) {
-      if (this._isInvalid || !this._isRelative) {
-        return;
-      }
-
-      this._path = [];
-      parse.call(this, value, 'relative path start');
-    },
-
-    get search() {
-      return this._isInvalid || !this._query || this._query === '?' ? '' : this._query;
-    },
-
-    set search(value) {
-      if (this._isInvalid || !this._isRelative) {
-        return;
-      }
-
-      this._query = '?';
-
-      if (value[0] === '?') {
-        value = value.slice(1);
-      }
-
-      parse.call(this, value, 'query');
-    },
-
-    get hash() {
-      return this._isInvalid || !this._fragment || this._fragment === '#' ? '' : this._fragment;
-    },
-
-    set hash(value) {
-      if (this._isInvalid) {
-        return;
-      }
-
-      this._fragment = '#';
-
-      if (value[0] === '#') {
-        value = value.slice(1);
-      }
-
-      parse.call(this, value, 'fragment');
-    },
-
-    get origin() {
-      var host;
-
-      if (this._isInvalid || !this._scheme) {
-        return '';
-      }
-
-      switch (this._scheme) {
-        case 'data':
-        case 'file':
-        case 'javascript':
-        case 'mailto':
-          return 'null';
-
-        case 'blob':
-          try {
-            return new JURL(this._schemeData).origin || 'null';
-          } catch (_) {}
-
-          return 'null';
-      }
-
-      host = this.host;
-
-      if (!host) {
-        return '';
-      }
-
-      return this._scheme + '://' + host;
-    }
-
-  };
-  exports.URL = JURL;
-})();
-
-/***/ }),
-/* 147 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getDocument = getDocument;
-exports.setPDFNetworkStreamFactory = setPDFNetworkStreamFactory;
-exports.build = exports.version = exports.PDFPageProxy = exports.PDFDocumentProxy = exports.PDFWorker = exports.PDFDataRangeTransport = exports.LoopbackPort = void 0;
-
-var _regenerator = _interopRequireDefault(__w_pdfjs_require__(148));
-
-var _util = __w_pdfjs_require__(1);
-
-var _display_utils = __w_pdfjs_require__(151);
-
-var _font_loader = __w_pdfjs_require__(152);
-
-var _api_compatibility = __w_pdfjs_require__(153);
-
-var _canvas = __w_pdfjs_require__(154);
-
-var _global_scope = _interopRequireDefault(__w_pdfjs_require__(3));
-
-var _worker_options = __w_pdfjs_require__(156);
-
-var _message_handler = __w_pdfjs_require__(157);
-
-var _metadata = __w_pdfjs_require__(158);
-
-var _transport_stream = __w_pdfjs_require__(160);
-
-var _webgl = __w_pdfjs_require__(161);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
-
-function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
-
-function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-var DEFAULT_RANGE_CHUNK_SIZE = 65536;
-var isWorkerDisabled = false;
-var fallbackWorkerSrc;
-var fakeWorkerFilesLoader = null;
-{
-  var useRequireEnsure = false;
-
-  if (typeof window === 'undefined') {
-    isWorkerDisabled = true;
-
-    if (typeof require.ensure === 'undefined') {
-      require.ensure = require('node-ensure');
-    }
-
-    useRequireEnsure = true;
-  } else if (typeof require !== 'undefined' && typeof require.ensure === 'function') {
-    useRequireEnsure = true;
-  }
-
-  if (typeof requirejs !== 'undefined' && requirejs.toUrl) {
-    fallbackWorkerSrc = requirejs.toUrl('pdfjs-dist/build/pdf.worker.js');
-  }
-
-  var dynamicLoaderSupported = typeof requirejs !== 'undefined' && requirejs.load;
-  fakeWorkerFilesLoader = useRequireEnsure ? function () {
-    return new Promise(function (resolve, reject) {
-      require.ensure([], function () {
-        try {
-          var worker;
-          worker = require('./pdf.worker.js');
-          resolve(worker.WorkerMessageHandler);
-        } catch (ex) {
-          reject(ex);
-        }
-      }, reject, 'pdfjsWorker');
-    });
-  } : dynamicLoaderSupported ? function () {
-    return new Promise(function (resolve, reject) {
-      requirejs(['pdfjs-dist/build/pdf.worker'], function (worker) {
-        try {
-          resolve(worker.WorkerMessageHandler);
-        } catch (ex) {
-          reject(ex);
-        }
-      }, reject);
-    });
-  } : null;
-
-  if (!fallbackWorkerSrc && (typeof document === "undefined" ? "undefined" : _typeof(document)) === 'object' && 'currentScript' in document) {
-    var pdfjsFilePath = document.currentScript && document.currentScript.src;
-
-    if (pdfjsFilePath) {
-      fallbackWorkerSrc = pdfjsFilePath.replace(/(\.(?:min\.)?js)(\?.*)?$/i, '.worker$1$2');
-    }
-  }
-}
-var createPDFNetworkStream;
-
-function setPDFNetworkStreamFactory(pdfNetworkStreamFactory) {
-  createPDFNetworkStream = pdfNetworkStreamFactory;
-}
-
-function getDocument(src) {
-  var task = new PDFDocumentLoadingTask();
-  var source;
-
-  if (typeof src === 'string') {
-    source = {
-      url: src
-    };
-  } else if ((0, _util.isArrayBuffer)(src)) {
-    source = {
-      data: src
-    };
-  } else if (src instanceof PDFDataRangeTransport) {
-    source = {
-      range: src
-    };
-  } else {
-    if (_typeof(src) !== 'object') {
-      throw new Error('Invalid parameter in getDocument, ' + 'need either Uint8Array, string or a parameter object');
-    }
-
-    if (!src.url && !src.data && !src.range) {
-      throw new Error('Invalid parameter object: need either .data, .range or .url');
-    }
-
-    source = src;
-  }
-
-  var params = Object.create(null);
-  var rangeTransport = null,
-      worker = null;
-
-  for (var key in source) {
-    if (key === 'url' && typeof window !== 'undefined') {
-      params[key] = new _util.URL(source[key], window.location).href;
-      continue;
-    } else if (key === 'range') {
-      rangeTransport = source[key];
-      continue;
-    } else if (key === 'worker') {
-      worker = source[key];
-      continue;
-    } else if (key === 'data' && !(source[key] instanceof Uint8Array)) {
-      var pdfBytes = source[key];
-
-      if (typeof pdfBytes === 'string') {
-        params[key] = (0, _util.stringToBytes)(pdfBytes);
-      } else if (_typeof(pdfBytes) === 'object' && pdfBytes !== null && !isNaN(pdfBytes.length)) {
-        params[key] = new Uint8Array(pdfBytes);
-      } else if ((0, _util.isArrayBuffer)(pdfBytes)) {
-        params[key] = new Uint8Array(pdfBytes);
-      } else {
-        throw new Error('Invalid PDF binary data: either typed array, ' + 'string or array-like object is expected in the ' + 'data property.');
-      }
-
-      continue;
-    }
-
-    params[key] = source[key];
-  }
-
-  params.rangeChunkSize = params.rangeChunkSize || DEFAULT_RANGE_CHUNK_SIZE;
-  params.CMapReaderFactory = params.CMapReaderFactory || _display_utils.DOMCMapReaderFactory;
-  params.ignoreErrors = params.stopAtErrors !== true;
-  params.pdfBug = params.pdfBug === true;
-  var NativeImageDecoderValues = Object.values(_util.NativeImageDecoding);
-
-  if (params.nativeImageDecoderSupport === undefined || !NativeImageDecoderValues.includes(params.nativeImageDecoderSupport)) {
-    params.nativeImageDecoderSupport = _api_compatibility.apiCompatibilityParams.nativeImageDecoderSupport || _util.NativeImageDecoding.DECODE;
-  }
-
-  if (!Number.isInteger(params.maxImageSize)) {
-    params.maxImageSize = -1;
-  }
-
-  if (typeof params.isEvalSupported !== 'boolean') {
-    params.isEvalSupported = true;
-  }
-
-  if (typeof params.disableFontFace !== 'boolean') {
-    params.disableFontFace = _api_compatibility.apiCompatibilityParams.disableFontFace || false;
-  }
-
-  if (typeof params.disableRange !== 'boolean') {
-    params.disableRange = false;
-  }
-
-  if (typeof params.disableStream !== 'boolean') {
-    params.disableStream = false;
-  }
-
-  if (typeof params.disableAutoFetch !== 'boolean') {
-    params.disableAutoFetch = false;
-  }
-
-  if (typeof params.disableCreateObjectURL !== 'boolean') {
-    params.disableCreateObjectURL = _api_compatibility.apiCompatibilityParams.disableCreateObjectURL || false;
-  }
-
-  (0, _util.setVerbosityLevel)(params.verbosity);
-
-  if (!worker) {
-    var workerParams = {
-      postMessageTransfers: params.postMessageTransfers,
-      verbosity: params.verbosity,
-      port: _worker_options.GlobalWorkerOptions.workerPort
-    };
-    worker = workerParams.port ? PDFWorker.fromPort(workerParams) : new PDFWorker(workerParams);
-    task._worker = worker;
-  }
-
-  var docId = task.docId;
-  worker.promise.then(function () {
-    if (task.destroyed) {
-      throw new Error('Loading aborted');
-    }
-
-    return _fetchDocument(worker, params, rangeTransport, docId).then(function (workerId) {
-      if (task.destroyed) {
-        throw new Error('Loading aborted');
-      }
-
-      var networkStream;
-
-      if (rangeTransport) {
-        networkStream = new _transport_stream.PDFDataTransportStream({
-          length: params.length,
-          initialData: params.initialData,
-          progressiveDone: params.progressiveDone,
-          disableRange: params.disableRange,
-          disableStream: params.disableStream
-        }, rangeTransport);
-      } else if (!params.data) {
-        networkStream = createPDFNetworkStream({
-          url: params.url,
-          length: params.length,
-          httpHeaders: params.httpHeaders,
-          withCredentials: params.withCredentials,
-          rangeChunkSize: params.rangeChunkSize,
-          disableRange: params.disableRange,
-          disableStream: params.disableStream
-        });
-      }
-
-      var messageHandler = new _message_handler.MessageHandler(docId, workerId, worker.port);
-      messageHandler.postMessageTransfers = worker.postMessageTransfers;
-      var transport = new WorkerTransport(messageHandler, task, networkStream, params);
-      task._transport = transport;
-      messageHandler.send('Ready', null);
-    });
-  })["catch"](task._capability.reject);
-  return task;
-}
-
-function _fetchDocument(worker, source, pdfDataRangeTransport, docId) {
-  if (worker.destroyed) {
-    return Promise.reject(new Error('Worker was destroyed'));
-  }
-
-  if (pdfDataRangeTransport) {
-    source.length = pdfDataRangeTransport.length;
-    source.initialData = pdfDataRangeTransport.initialData;
-    source.progressiveDone = pdfDataRangeTransport.progressiveDone;
-  }
-
-  return worker.messageHandler.sendWithPromise('GetDocRequest', {
-    docId: docId,
-    apiVersion: '2.2.230',
-    source: {
-      data: source.data,
-      url: source.url,
-      password: source.password,
-      disableAutoFetch: source.disableAutoFetch,
-      rangeChunkSize: source.rangeChunkSize,
-      length: source.length
-    },
-    maxImageSize: source.maxImageSize,
-    disableFontFace: source.disableFontFace,
-    disableCreateObjectURL: source.disableCreateObjectURL,
-    postMessageTransfers: worker.postMessageTransfers,
-    docBaseUrl: source.docBaseUrl,
-    nativeImageDecoderSupport: source.nativeImageDecoderSupport,
-    ignoreErrors: source.ignoreErrors,
-    isEvalSupported: source.isEvalSupported
-  }).then(function (workerId) {
-    if (worker.destroyed) {
-      throw new Error('Worker was destroyed');
-    }
-
-    return workerId;
-  });
-}
-
-var PDFDocumentLoadingTask = function PDFDocumentLoadingTaskClosure() {
-  var nextDocumentId = 0;
-
-  var PDFDocumentLoadingTask =
-  /*#__PURE__*/
-  function () {
-    function PDFDocumentLoadingTask() {
-      _classCallCheck(this, PDFDocumentLoadingTask);
-
-      this._capability = (0, _util.createPromiseCapability)();
-      this._transport = null;
-      this._worker = null;
-      this.docId = 'd' + nextDocumentId++;
-      this.destroyed = false;
-      this.onPassword = null;
-      this.onProgress = null;
-      this.onUnsupportedFeature = null;
-    }
-
-    _createClass(PDFDocumentLoadingTask, [{
-      key: "destroy",
-      value: function destroy() {
-        var _this = this;
-
-        this.destroyed = true;
-        var transportDestroyed = !this._transport ? Promise.resolve() : this._transport.destroy();
-        return transportDestroyed.then(function () {
-          _this._transport = null;
-
-          if (_this._worker) {
-            _this._worker.destroy();
-
-            _this._worker = null;
-          }
-        });
-      }
-    }, {
-      key: "then",
-      value: function then(onFulfilled, onRejected) {
-        (0, _display_utils.deprecated)('PDFDocumentLoadingTask.then method, ' + 'use the `promise` getter instead.');
-        return this.promise.then.apply(this.promise, arguments);
-      }
-    }, {
-      key: "promise",
-      get: function get() {
-        return this._capability.promise;
-      }
-    }]);
-
-    return PDFDocumentLoadingTask;
-  }();
-
-  return PDFDocumentLoadingTask;
-}();
-
-var PDFDataRangeTransport =
-/*#__PURE__*/
-function () {
-  function PDFDataRangeTransport(length, initialData) {
-    var progressiveDone = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-
-    _classCallCheck(this, PDFDataRangeTransport);
-
-    this.length = length;
-    this.initialData = initialData;
-    this.progressiveDone = progressiveDone;
-    this._rangeListeners = [];
-    this._progressListeners = [];
-    this._progressiveReadListeners = [];
-    this._progressiveDoneListeners = [];
-    this._readyCapability = (0, _util.createPromiseCapability)();
-  }
-
-  _createClass(PDFDataRangeTransport, [{
-    key: "addRangeListener",
-    value: function addRangeListener(listener) {
-      this._rangeListeners.push(listener);
-    }
-  }, {
-    key: "addProgressListener",
-    value: function addProgressListener(listener) {
-      this._progressListeners.push(listener);
-    }
-  }, {
-    key: "addProgressiveReadListener",
-    value: function addProgressiveReadListener(listener) {
-      this._progressiveReadListeners.push(listener);
-    }
-  }, {
-    key: "addProgressiveDoneListener",
-    value: function addProgressiveDoneListener(listener) {
-      this._progressiveDoneListeners.push(listener);
-    }
-  }, {
-    key: "onDataRange",
-    value: function onDataRange(begin, chunk) {
-      var _iteratorNormalCompletion = true;
-      var _didIteratorError = false;
-      var _iteratorError = undefined;
-
-      try {
-        for (var _iterator = this._rangeListeners[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-          var listener = _step.value;
-          listener(begin, chunk);
-        }
-      } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion && _iterator["return"] != null) {
-            _iterator["return"]();
-          }
-        } finally {
-          if (_didIteratorError) {
-            throw _iteratorError;
-          }
-        }
-      }
-    }
-  }, {
-    key: "onDataProgress",
-    value: function onDataProgress(loaded, total) {
-      var _this2 = this;
-
-      this._readyCapability.promise.then(function () {
-        var _iteratorNormalCompletion2 = true;
-        var _didIteratorError2 = false;
-        var _iteratorError2 = undefined;
-
-        try {
-          for (var _iterator2 = _this2._progressListeners[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-            var listener = _step2.value;
-            listener(loaded, total);
-          }
-        } catch (err) {
-          _didIteratorError2 = true;
-          _iteratorError2 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion2 && _iterator2["return"] != null) {
-              _iterator2["return"]();
-            }
-          } finally {
-            if (_didIteratorError2) {
-              throw _iteratorError2;
-            }
-          }
-        }
-      });
-    }
-  }, {
-    key: "onDataProgressiveRead",
-    value: function onDataProgressiveRead(chunk) {
-      var _this3 = this;
-
-      this._readyCapability.promise.then(function () {
-        var _iteratorNormalCompletion3 = true;
-        var _didIteratorError3 = false;
-        var _iteratorError3 = undefined;
-
-        try {
-          for (var _iterator3 = _this3._progressiveReadListeners[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
-            var listener = _step3.value;
-            listener(chunk);
-          }
-        } catch (err) {
-          _didIteratorError3 = true;
-          _iteratorError3 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion3 && _iterator3["return"] != null) {
-              _iterator3["return"]();
-            }
-          } finally {
-            if (_didIteratorError3) {
-              throw _iteratorError3;
-            }
-          }
-        }
-      });
-    }
-  }, {
-    key: "onDataProgressiveDone",
-    value: function onDataProgressiveDone() {
-      var _this4 = this;
-
-      this._readyCapability.promise.then(function () {
-        var _iteratorNormalCompletion4 = true;
-        var _didIteratorError4 = false;
-        var _iteratorError4 = undefined;
-
-        try {
-          for (var _iterator4 = _this4._progressiveDoneListeners[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
-            var listener = _step4.value;
-            listener();
-          }
-        } catch (err) {
-          _didIteratorError4 = true;
-          _iteratorError4 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion4 && _iterator4["return"] != null) {
-              _iterator4["return"]();
-            }
-          } finally {
-            if (_didIteratorError4) {
-              throw _iteratorError4;
-            }
-          }
-        }
-      });
-    }
-  }, {
-    key: "transportReady",
-    value: function transportReady() {
-      this._readyCapability.resolve();
-    }
-  }, {
-    key: "requestDataRange",
-    value: function requestDataRange(begin, end) {
-      (0, _util.unreachable)('Abstract method PDFDataRangeTransport.requestDataRange');
-    }
-  }, {
-    key: "abort",
-    value: function abort() {}
-  }]);
-
-  return PDFDataRangeTransport;
-}();
-
-exports.PDFDataRangeTransport = PDFDataRangeTransport;
-
-var PDFDocumentProxy =
-/*#__PURE__*/
-function () {
-  function PDFDocumentProxy(pdfInfo, transport) {
-    _classCallCheck(this, PDFDocumentProxy);
-
-    this._pdfInfo = pdfInfo;
-    this._transport = transport;
-  }
-
-  _createClass(PDFDocumentProxy, [{
-    key: "getPage",
-    value: function getPage(pageNumber) {
-      return this._transport.getPage(pageNumber);
-    }
-  }, {
-    key: "getPageIndex",
-    value: function getPageIndex(ref) {
-      return this._transport.getPageIndex(ref);
-    }
-  }, {
-    key: "getDestinations",
-    value: function getDestinations() {
-      return this._transport.getDestinations();
-    }
-  }, {
-    key: "getDestination",
-    value: function getDestination(id) {
-      return this._transport.getDestination(id);
-    }
-  }, {
-    key: "getPageLabels",
-    value: function getPageLabels() {
-      return this._transport.getPageLabels();
-    }
-  }, {
-    key: "getPageLayout",
-    value: function getPageLayout() {
-      return this._transport.getPageLayout();
-    }
-  }, {
-    key: "getPageMode",
-    value: function getPageMode() {
-      return this._transport.getPageMode();
-    }
-  }, {
-    key: "getViewerPreferences",
-    value: function getViewerPreferences() {
-      return this._transport.getViewerPreferences();
-    }
-  }, {
-    key: "getOpenActionDestination",
-    value: function getOpenActionDestination() {
-      return this._transport.getOpenActionDestination();
-    }
-  }, {
-    key: "getAttachments",
-    value: function getAttachments() {
-      return this._transport.getAttachments();
-    }
-  }, {
-    key: "getJavaScript",
-    value: function getJavaScript() {
-      return this._transport.getJavaScript();
-    }
-  }, {
-    key: "getOutline",
-    value: function getOutline() {
-      return this._transport.getOutline();
-    }
-  }, {
-    key: "getPermissions",
-    value: function getPermissions() {
-      return this._transport.getPermissions();
-    }
-  }, {
-    key: "getMetadata",
-    value: function getMetadata() {
-      return this._transport.getMetadata();
-    }
-  }, {
-    key: "getData",
-    value: function getData() {
-      return this._transport.getData();
-    }
-  }, {
-    key: "getDownloadInfo",
-    value: function getDownloadInfo() {
-      return this._transport.downloadInfoCapability.promise;
-    }
-  }, {
-    key: "getStats",
-    value: function getStats() {
-      return this._transport.getStats();
-    }
-  }, {
-    key: "cleanup",
-    value: function cleanup() {
-      this._transport.startCleanup();
-    }
-  }, {
-    key: "destroy",
-    value: function destroy() {
-      return this.loadingTask.destroy();
-    }
-  }, {
-    key: "numPages",
-    get: function get() {
-      return this._pdfInfo.numPages;
-    }
-  }, {
-    key: "fingerprint",
-    get: function get() {
-      return this._pdfInfo.fingerprint;
-    }
-  }, {
-    key: "loadingParams",
-    get: function get() {
-      return this._transport.loadingParams;
-    }
-  }, {
-    key: "loadingTask",
-    get: function get() {
-      return this._transport.loadingTask;
-    }
-  }]);
-
-  return PDFDocumentProxy;
-}();
-
-exports.PDFDocumentProxy = PDFDocumentProxy;
-
-var PDFPageProxy =
-/*#__PURE__*/
-function () {
-  function PDFPageProxy(pageIndex, pageInfo, transport) {
-    var pdfBug = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
-
-    _classCallCheck(this, PDFPageProxy);
-
-    this.pageIndex = pageIndex;
-    this._pageInfo = pageInfo;
-    this._transport = transport;
-    this._stats = pdfBug ? new _display_utils.StatTimer() : _display_utils.DummyStatTimer;
-    this._pdfBug = pdfBug;
-    this.commonObjs = transport.commonObjs;
-    this.objs = new PDFObjects();
-    this.cleanupAfterRender = false;
-    this.pendingCleanup = false;
-    this.intentStates = Object.create(null);
-    this.destroyed = false;
-  }
-
-  _createClass(PDFPageProxy, [{
-    key: "getViewport",
-    value: function getViewport() {
-      var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-          scale = _ref.scale,
-          _ref$rotation = _ref.rotation,
-          rotation = _ref$rotation === void 0 ? this.rotate : _ref$rotation,
-          _ref$dontFlip = _ref.dontFlip,
-          dontFlip = _ref$dontFlip === void 0 ? false : _ref$dontFlip;
-
-      if (arguments.length > 1 || typeof arguments[0] === 'number') {
-        (0, _display_utils.deprecated)('getViewport is called with obsolete arguments.');
-        scale = arguments[0];
-        rotation = typeof arguments[1] === 'number' ? arguments[1] : this.rotate;
-        dontFlip = typeof arguments[2] === 'boolean' ? arguments[2] : false;
-      }
-
-      return new _display_utils.PageViewport({
-        viewBox: this.view,
-        scale: scale,
-        rotation: rotation,
-        dontFlip: dontFlip
-      });
-    }
-  }, {
-    key: "getAnnotations",
-    value: function getAnnotations() {
-      var _ref2 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-          _ref2$intent = _ref2.intent,
-          intent = _ref2$intent === void 0 ? null : _ref2$intent;
-
-      if (!this.annotationsPromise || this.annotationsIntent !== intent) {
-        this.annotationsPromise = this._transport.getAnnotations(this.pageIndex, intent);
-        this.annotationsIntent = intent;
-      }
-
-      return this.annotationsPromise;
-    }
-  }, {
-    key: "render",
-    value: function render(_ref3) {
-      var _this5 = this;
-
-      var canvasContext = _ref3.canvasContext,
-          viewport = _ref3.viewport,
-          _ref3$intent = _ref3.intent,
-          intent = _ref3$intent === void 0 ? 'display' : _ref3$intent,
-          _ref3$enableWebGL = _ref3.enableWebGL,
-          enableWebGL = _ref3$enableWebGL === void 0 ? false : _ref3$enableWebGL,
-          _ref3$renderInteracti = _ref3.renderInteractiveForms,
-          renderInteractiveForms = _ref3$renderInteracti === void 0 ? false : _ref3$renderInteracti,
-          _ref3$transform = _ref3.transform,
-          transform = _ref3$transform === void 0 ? null : _ref3$transform,
-          _ref3$imageLayer = _ref3.imageLayer,
-          imageLayer = _ref3$imageLayer === void 0 ? null : _ref3$imageLayer,
-          _ref3$canvasFactory = _ref3.canvasFactory,
-          canvasFactory = _ref3$canvasFactory === void 0 ? null : _ref3$canvasFactory,
-          _ref3$background = _ref3.background,
-          background = _ref3$background === void 0 ? null : _ref3$background;
-      var stats = this._stats;
-      stats.time('Overall');
-      this.pendingCleanup = false;
-      var renderingIntent = intent === 'print' ? 'print' : 'display';
-      var canvasFactoryInstance = canvasFactory || new _display_utils.DOMCanvasFactory();
-      var webGLContext = new _webgl.WebGLContext({
-        enable: enableWebGL
-      });
-
-      if (!this.intentStates[renderingIntent]) {
-        this.intentStates[renderingIntent] = Object.create(null);
-      }
-
-      var intentState = this.intentStates[renderingIntent];
-
-      if (!intentState.displayReadyCapability) {
-        intentState.receivingOperatorList = true;
-        intentState.displayReadyCapability = (0, _util.createPromiseCapability)();
-        intentState.operatorList = {
-          fnArray: [],
-          argsArray: [],
-          lastChunk: false
-        };
-        stats.time('Page Request');
-
-        this._transport.messageHandler.send('RenderPageRequest', {
-          pageIndex: this.pageNumber - 1,
-          intent: renderingIntent,
-          renderInteractiveForms: renderInteractiveForms === true
-        });
-      }
-
-      var complete = function complete(error) {
-        var i = intentState.renderTasks.indexOf(internalRenderTask);
-
-        if (i >= 0) {
-          intentState.renderTasks.splice(i, 1);
-        }
-
-        if (_this5.cleanupAfterRender || renderingIntent === 'print') {
-          _this5.pendingCleanup = true;
-        }
-
-        _this5._tryCleanup();
-
-        if (error) {
-          internalRenderTask.capability.reject(error);
-        } else {
-          internalRenderTask.capability.resolve();
-        }
-
-        stats.timeEnd('Rendering');
-        stats.timeEnd('Overall');
-      };
-
-      var internalRenderTask = new InternalRenderTask({
-        callback: complete,
-        params: {
-          canvasContext: canvasContext,
-          viewport: viewport,
-          transform: transform,
-          imageLayer: imageLayer,
-          background: background
-        },
-        objs: this.objs,
-        commonObjs: this.commonObjs,
-        operatorList: intentState.operatorList,
-        pageNumber: this.pageNumber,
-        canvasFactory: canvasFactoryInstance,
-        webGLContext: webGLContext,
-        useRequestAnimationFrame: renderingIntent !== 'print',
-        pdfBug: this._pdfBug
-      });
-
-      if (!intentState.renderTasks) {
-        intentState.renderTasks = [];
-      }
-
-      intentState.renderTasks.push(internalRenderTask);
-      var renderTask = internalRenderTask.task;
-      intentState.displayReadyCapability.promise.then(function (transparency) {
-        if (_this5.pendingCleanup) {
-          complete();
-          return;
-        }
-
-        stats.time('Rendering');
-        internalRenderTask.initializeGraphics(transparency);
-        internalRenderTask.operatorListChanged();
-      })["catch"](complete);
-      return renderTask;
-    }
-  }, {
-    key: "getOperatorList",
-    value: function getOperatorList() {
-      function operatorListChanged() {
-        if (intentState.operatorList.lastChunk) {
-          intentState.opListReadCapability.resolve(intentState.operatorList);
-          var i = intentState.renderTasks.indexOf(opListTask);
-
-          if (i >= 0) {
-            intentState.renderTasks.splice(i, 1);
-          }
-        }
-      }
-
-      var renderingIntent = 'oplist';
-
-      if (!this.intentStates[renderingIntent]) {
-        this.intentStates[renderingIntent] = Object.create(null);
-      }
-
-      var intentState = this.intentStates[renderingIntent];
-      var opListTask;
-
-      if (!intentState.opListReadCapability) {
-        opListTask = {};
-        opListTask.operatorListChanged = operatorListChanged;
-        intentState.receivingOperatorList = true;
-        intentState.opListReadCapability = (0, _util.createPromiseCapability)();
-        intentState.renderTasks = [];
-        intentState.renderTasks.push(opListTask);
-        intentState.operatorList = {
-          fnArray: [],
-          argsArray: [],
-          lastChunk: false
-        };
-
-        this._stats.time('Page Request');
-
-        this._transport.messageHandler.send('RenderPageRequest', {
-          pageIndex: this.pageIndex,
-          intent: renderingIntent
-        });
-      }
-
-      return intentState.opListReadCapability.promise;
-    }
-  }, {
-    key: "streamTextContent",
-    value: function streamTextContent() {
-      var _ref4 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-          _ref4$normalizeWhites = _ref4.normalizeWhitespace,
-          normalizeWhitespace = _ref4$normalizeWhites === void 0 ? false : _ref4$normalizeWhites,
-          _ref4$disableCombineT = _ref4.disableCombineTextItems,
-          disableCombineTextItems = _ref4$disableCombineT === void 0 ? false : _ref4$disableCombineT;
-
-      var TEXT_CONTENT_CHUNK_SIZE = 100;
-      return this._transport.messageHandler.sendWithStream('GetTextContent', {
-        pageIndex: this.pageNumber - 1,
-        normalizeWhitespace: normalizeWhitespace === true,
-        combineTextItems: disableCombineTextItems !== true
-      }, {
-        highWaterMark: TEXT_CONTENT_CHUNK_SIZE,
-        size: function size(textContent) {
-          return textContent.items.length;
-        }
-      });
-    }
-  }, {
-    key: "getTextContent",
-    value: function getTextContent() {
-      var params = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-      var readableStream = this.streamTextContent(params);
-      return new Promise(function (resolve, reject) {
-        function pump() {
-          reader.read().then(function (_ref5) {
-            var _textContent$items;
-
-            var value = _ref5.value,
-                done = _ref5.done;
-
-            if (done) {
-              resolve(textContent);
-              return;
-            }
-
-            Object.assign(textContent.styles, value.styles);
-
-            (_textContent$items = textContent.items).push.apply(_textContent$items, _toConsumableArray(value.items));
-
-            pump();
-          }, reject);
-        }
-
-        var reader = readableStream.getReader();
-        var textContent = {
-          items: [],
-          styles: Object.create(null)
-        };
-        pump();
-      });
-    }
-  }, {
-    key: "_destroy",
-    value: function _destroy() {
-      this.destroyed = true;
-      this._transport.pageCache[this.pageIndex] = null;
-      var waitOn = [];
-      Object.keys(this.intentStates).forEach(function (intent) {
-        if (intent === 'oplist') {
-          return;
-        }
-
-        var intentState = this.intentStates[intent];
-        intentState.renderTasks.forEach(function (renderTask) {
-          var renderCompleted = renderTask.capability.promise["catch"](function () {});
-          waitOn.push(renderCompleted);
-          renderTask.cancel();
-        });
-      }, this);
-      this.objs.clear();
-      this.annotationsPromise = null;
-      this.pendingCleanup = false;
-      return Promise.all(waitOn);
-    }
-  }, {
-    key: "cleanup",
-    value: function cleanup() {
-      var resetStats = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-      this.pendingCleanup = true;
-
-      this._tryCleanup(resetStats);
-    }
-  }, {
-    key: "_tryCleanup",
-    value: function _tryCleanup() {
-      var resetStats = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-
-      if (!this.pendingCleanup || Object.keys(this.intentStates).some(function (intent) {
-        var intentState = this.intentStates[intent];
-        return intentState.renderTasks.length !== 0 || intentState.receivingOperatorList;
-      }, this)) {
-        return;
-      }
-
-      Object.keys(this.intentStates).forEach(function (intent) {
-        delete this.intentStates[intent];
-      }, this);
-      this.objs.clear();
-      this.annotationsPromise = null;
-
-      if (resetStats && this._stats instanceof _display_utils.StatTimer) {
-        this._stats = new _display_utils.StatTimer();
-      }
-
-      this.pendingCleanup = false;
-    }
-  }, {
-    key: "_startRenderPage",
-    value: function _startRenderPage(transparency, intent) {
-      var intentState = this.intentStates[intent];
-
-      if (intentState.displayReadyCapability) {
-        intentState.displayReadyCapability.resolve(transparency);
-      }
-    }
-  }, {
-    key: "_renderPageChunk",
-    value: function _renderPageChunk(operatorListChunk, intent) {
-      var intentState = this.intentStates[intent];
-
-      for (var i = 0, ii = operatorListChunk.length; i < ii; i++) {
-        intentState.operatorList.fnArray.push(operatorListChunk.fnArray[i]);
-        intentState.operatorList.argsArray.push(operatorListChunk.argsArray[i]);
-      }
-
-      intentState.operatorList.lastChunk = operatorListChunk.lastChunk;
-
-      for (var _i = 0; _i < intentState.renderTasks.length; _i++) {
-        intentState.renderTasks[_i].operatorListChanged();
-      }
-
-      if (operatorListChunk.lastChunk) {
-        intentState.receivingOperatorList = false;
-
-        this._tryCleanup();
-      }
-    }
-  }, {
-    key: "pageNumber",
-    get: function get() {
-      return this.pageIndex + 1;
-    }
-  }, {
-    key: "rotate",
-    get: function get() {
-      return this._pageInfo.rotate;
-    }
-  }, {
-    key: "ref",
-    get: function get() {
-      return this._pageInfo.ref;
-    }
-  }, {
-    key: "userUnit",
-    get: function get() {
-      return this._pageInfo.userUnit;
-    }
-  }, {
-    key: "view",
-    get: function get() {
-      return this._pageInfo.view;
-    }
-  }, {
-    key: "stats",
-    get: function get() {
-      return this._stats instanceof _display_utils.StatTimer ? this._stats : null;
-    }
-  }]);
-
-  return PDFPageProxy;
-}();
-
-exports.PDFPageProxy = PDFPageProxy;
-
-var LoopbackPort =
-/*#__PURE__*/
-function () {
-  function LoopbackPort() {
-    var defer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-
-    _classCallCheck(this, LoopbackPort);
-
-    this._listeners = [];
-    this._defer = defer;
-    this._deferred = Promise.resolve(undefined);
-  }
-
-  _createClass(LoopbackPort, [{
-    key: "postMessage",
-    value: function postMessage(obj, transfers) {
-      var _this6 = this;
-
-      function cloneValue(value) {
-        if (_typeof(value) !== 'object' || value === null) {
-          return value;
-        }
-
-        if (cloned.has(value)) {
-          return cloned.get(value);
-        }
-
-        var buffer, result;
-
-        if ((buffer = value.buffer) && (0, _util.isArrayBuffer)(buffer)) {
-          var transferable = transfers && transfers.includes(buffer);
-
-          if (value === buffer) {
-            result = value;
-          } else if (transferable) {
-            result = new value.constructor(buffer, value.byteOffset, value.byteLength);
-          } else {
-            result = new value.constructor(value);
-          }
-
-          cloned.set(value, result);
-          return result;
-        }
-
-        result = Array.isArray(value) ? [] : {};
-        cloned.set(value, result);
-
-        for (var i in value) {
-          var desc = void 0,
-              p = value;
-
-          while (!(desc = Object.getOwnPropertyDescriptor(p, i))) {
-            p = Object.getPrototypeOf(p);
-          }
-
-          if (typeof desc.value === 'undefined' || typeof desc.value === 'function') {
-            continue;
-          }
-
-          result[i] = cloneValue(desc.value);
-        }
-
-        return result;
-      }
-
-      if (!this._defer) {
-        this._listeners.forEach(function (listener) {
-          listener.call(this, {
-            data: obj
-          });
-        }, this);
-
-        return;
-      }
-
-      var cloned = new WeakMap();
-      var e = {
-        data: cloneValue(obj)
-      };
-
-      this._deferred.then(function () {
-        _this6._listeners.forEach(function (listener) {
-          listener.call(this, e);
-        }, _this6);
-      });
-    }
-  }, {
-    key: "addEventListener",
-    value: function addEventListener(name, listener) {
-      this._listeners.push(listener);
-    }
-  }, {
-    key: "removeEventListener",
-    value: function removeEventListener(name, listener) {
-      var i = this._listeners.indexOf(listener);
-
-      this._listeners.splice(i, 1);
-    }
-  }, {
-    key: "terminate",
-    value: function terminate() {
-      this._listeners.length = 0;
-    }
-  }]);
-
-  return LoopbackPort;
-}();
-
-exports.LoopbackPort = LoopbackPort;
-
-var PDFWorker = function PDFWorkerClosure() {
-  var pdfWorkerPorts = new WeakMap();
-  var nextFakeWorkerId = 0;
-  var fakeWorkerFilesLoadedCapability;
-
-  function _getWorkerSrc() {
-    if (_worker_options.GlobalWorkerOptions.workerSrc) {
-      return _worker_options.GlobalWorkerOptions.workerSrc;
-    }
-
-    if (typeof fallbackWorkerSrc !== 'undefined') {
-      return fallbackWorkerSrc;
-    }
-
-    throw new Error('No "GlobalWorkerOptions.workerSrc" specified.');
-  }
-
-  function getMainThreadWorkerMessageHandler() {
-    try {
-      if (typeof window !== 'undefined') {
-        return window.pdfjsWorker && window.pdfjsWorker.WorkerMessageHandler;
-      }
-    } catch (ex) {}
-
-    return null;
-  }
-
-  function setupFakeWorkerGlobal() {
-    if (fakeWorkerFilesLoadedCapability) {
-      return fakeWorkerFilesLoadedCapability.promise;
-    }
-
-    fakeWorkerFilesLoadedCapability = (0, _util.createPromiseCapability)();
-    var mainWorkerMessageHandler = getMainThreadWorkerMessageHandler();
-
-    if (mainWorkerMessageHandler) {
-      fakeWorkerFilesLoadedCapability.resolve(mainWorkerMessageHandler);
-      return fakeWorkerFilesLoadedCapability.promise;
-    }
-
-    var loader = fakeWorkerFilesLoader || function () {
-      return (0, _display_utils.loadScript)(_getWorkerSrc()).then(function () {
-        return window.pdfjsWorker.WorkerMessageHandler;
-      });
-    };
-
-    loader().then(fakeWorkerFilesLoadedCapability.resolve, fakeWorkerFilesLoadedCapability.reject);
-    return fakeWorkerFilesLoadedCapability.promise;
-  }
-
-  function createCDNWrapper(url) {
-    var wrapper = 'importScripts(\'' + url + '\');';
-    return _util.URL.createObjectURL(new Blob([wrapper]));
-  }
-
-  var PDFWorker =
-  /*#__PURE__*/
-  function () {
-    function PDFWorker() {
-      var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-          _ref6$name = _ref6.name,
-          name = _ref6$name === void 0 ? null : _ref6$name,
-          _ref6$port = _ref6.port,
-          port = _ref6$port === void 0 ? null : _ref6$port,
-          _ref6$postMessageTran = _ref6.postMessageTransfers,
-          postMessageTransfers = _ref6$postMessageTran === void 0 ? true : _ref6$postMessageTran,
-          _ref6$verbosity = _ref6.verbosity,
-          verbosity = _ref6$verbosity === void 0 ? (0, _util.getVerbosityLevel)() : _ref6$verbosity;
-
-      _classCallCheck(this, PDFWorker);
-
-      if (port && pdfWorkerPorts.has(port)) {
-        throw new Error('Cannot use more than one PDFWorker per port');
-      }
-
-      this.name = name;
-      this.destroyed = false;
-      this.postMessageTransfers = postMessageTransfers !== false;
-      this.verbosity = verbosity;
-      this._readyCapability = (0, _util.createPromiseCapability)();
-      this._port = null;
-      this._webWorker = null;
-      this._messageHandler = null;
-
-      if (port) {
-        pdfWorkerPorts.set(port, this);
-
-        this._initializeFromPort(port);
-
-        return;
-      }
-
-      this._initialize();
-    }
-
-    _createClass(PDFWorker, [{
-      key: "_initializeFromPort",
-      value: function _initializeFromPort(port) {
-        this._port = port;
-        this._messageHandler = new _message_handler.MessageHandler('main', 'worker', port);
-
-        this._messageHandler.on('ready', function () {});
-
-        this._readyCapability.resolve();
-      }
-    }, {
-      key: "_initialize",
-      value: function _initialize() {
-        var _this7 = this;
-
-        if (typeof Worker !== 'undefined' && !isWorkerDisabled && !getMainThreadWorkerMessageHandler()) {
-          var workerSrc = _getWorkerSrc();
-
-          try {
-            if (!(0, _util.isSameOrigin)(window.location.href, workerSrc)) {
-              workerSrc = createCDNWrapper(new _util.URL(workerSrc, window.location).href);
-            }
-
-            var worker = new Worker(workerSrc);
-            var messageHandler = new _message_handler.MessageHandler('main', 'worker', worker);
-
-            var terminateEarly = function terminateEarly() {
-              worker.removeEventListener('error', onWorkerError);
-              messageHandler.destroy();
-              worker.terminate();
-
-              if (_this7.destroyed) {
-                _this7._readyCapability.reject(new Error('Worker was destroyed'));
-              } else {
-                _this7._setupFakeWorker();
-              }
-            };
-
-            var onWorkerError = function onWorkerError() {
-              if (!_this7._webWorker) {
-                terminateEarly();
-              }
-            };
-
-            worker.addEventListener('error', onWorkerError);
-            messageHandler.on('test', function (data) {
-              worker.removeEventListener('error', onWorkerError);
-
-              if (_this7.destroyed) {
-                terminateEarly();
-                return;
-              }
-
-              if (data && data.supportTypedArray) {
-                _this7._messageHandler = messageHandler;
-                _this7._port = worker;
-                _this7._webWorker = worker;
-
-                if (!data.supportTransfers) {
-                  _this7.postMessageTransfers = false;
-                }
-
-                _this7._readyCapability.resolve();
-
-                messageHandler.send('configure', {
-                  verbosity: _this7.verbosity
-                });
-              } else {
-                _this7._setupFakeWorker();
-
-                messageHandler.destroy();
-                worker.terminate();
-              }
-            });
-            messageHandler.on('ready', function (data) {
-              worker.removeEventListener('error', onWorkerError);
-
-              if (_this7.destroyed) {
-                terminateEarly();
-                return;
-              }
-
-              try {
-                sendTest();
-              } catch (e) {
-                _this7._setupFakeWorker();
-              }
-            });
-
-            var sendTest = function sendTest() {
-              var testObj = new Uint8Array([_this7.postMessageTransfers ? 255 : 0]);
-
-              try {
-                messageHandler.send('test', testObj, [testObj.buffer]);
-              } catch (ex) {
-                (0, _util.info)('Cannot use postMessage transfers');
-                testObj[0] = 0;
-                messageHandler.send('test', testObj);
-              }
-            };
-
-            sendTest();
-            return;
-          } catch (e) {
-            (0, _util.info)('The worker has been disabled.');
-          }
-        }
-
-        this._setupFakeWorker();
-      }
-    }, {
-      key: "_setupFakeWorker",
-      value: function _setupFakeWorker() {
-        var _this8 = this;
-
-        if (!isWorkerDisabled) {
-          (0, _util.warn)('Setting up fake worker.');
-          isWorkerDisabled = true;
-        }
-
-        setupFakeWorkerGlobal().then(function (WorkerMessageHandler) {
-          if (_this8.destroyed) {
-            _this8._readyCapability.reject(new Error('Worker was destroyed'));
-
-            return;
-          }
-
-          var port = new LoopbackPort();
-          _this8._port = port;
-          var id = 'fake' + nextFakeWorkerId++;
-          var workerHandler = new _message_handler.MessageHandler(id + '_worker', id, port);
-          WorkerMessageHandler.setup(workerHandler, port);
-          var messageHandler = new _message_handler.MessageHandler(id, id + '_worker', port);
-          _this8._messageHandler = messageHandler;
-
-          _this8._readyCapability.resolve();
-        })["catch"](function (reason) {
-          _this8._readyCapability.reject(new Error("Setting up fake worker failed: \"".concat(reason.message, "\".")));
-        });
-      }
-    }, {
-      key: "destroy",
-      value: function destroy() {
-        this.destroyed = true;
-
-        if (this._webWorker) {
-          this._webWorker.terminate();
-
-          this._webWorker = null;
-        }
-
-        pdfWorkerPorts["delete"](this._port);
-        this._port = null;
-
-        if (this._messageHandler) {
-          this._messageHandler.destroy();
-
-          this._messageHandler = null;
-        }
-      }
-    }, {
-      key: "promise",
-      get: function get() {
-        return this._readyCapability.promise;
-      }
-    }, {
-      key: "port",
-      get: function get() {
-        return this._port;
-      }
-    }, {
-      key: "messageHandler",
-      get: function get() {
-        return this._messageHandler;
-      }
-    }], [{
-      key: "fromPort",
-      value: function fromPort(params) {
-        if (!params || !params.port) {
-          throw new Error('PDFWorker.fromPort - invalid method signature.');
-        }
-
-        if (pdfWorkerPorts.has(params.port)) {
-          return pdfWorkerPorts.get(params.port);
-        }
-
-        return new PDFWorker(params);
-      }
-    }, {
-      key: "getWorkerSrc",
-      value: function getWorkerSrc() {
-        return _getWorkerSrc();
-      }
-    }]);
-
-    return PDFWorker;
-  }();
-
-  return PDFWorker;
-}();
-
-exports.PDFWorker = PDFWorker;
-
-var WorkerTransport =
-/*#__PURE__*/
-function () {
-  function WorkerTransport(messageHandler, loadingTask, networkStream, params) {
-    _classCallCheck(this, WorkerTransport);
-
-    this.messageHandler = messageHandler;
-    this.loadingTask = loadingTask;
-    this.commonObjs = new PDFObjects();
-    this.fontLoader = new _font_loader.FontLoader({
-      docId: loadingTask.docId,
-      onUnsupportedFeature: this._onUnsupportedFeature.bind(this)
-    });
-    this._params = params;
-    this.CMapReaderFactory = new params.CMapReaderFactory({
-      baseUrl: params.cMapUrl,
-      isCompressed: params.cMapPacked
-    });
-    this.destroyed = false;
-    this.destroyCapability = null;
-    this._passwordCapability = null;
-    this._networkStream = networkStream;
-    this._fullReader = null;
-    this._lastProgress = null;
-    this.pageCache = [];
-    this.pagePromises = [];
-    this.downloadInfoCapability = (0, _util.createPromiseCapability)();
-    this.setupMessageHandler();
-  }
-
-  _createClass(WorkerTransport, [{
-    key: "destroy",
-    value: function destroy() {
-      var _this9 = this;
-
-      if (this.destroyCapability) {
-        return this.destroyCapability.promise;
-      }
-
-      this.destroyed = true;
-      this.destroyCapability = (0, _util.createPromiseCapability)();
-
-      if (this._passwordCapability) {
-        this._passwordCapability.reject(new Error('Worker was destroyed during onPassword callback'));
-      }
-
-      var waitOn = [];
-      this.pageCache.forEach(function (page) {
-        if (page) {
-          waitOn.push(page._destroy());
-        }
-      });
-      this.pageCache.length = 0;
-      this.pagePromises.length = 0;
-      var terminated = this.messageHandler.sendWithPromise('Terminate', null);
-      waitOn.push(terminated);
-      Promise.all(waitOn).then(function () {
-        _this9.fontLoader.clear();
-
-        if (_this9._networkStream) {
-          _this9._networkStream.cancelAllRequests();
-        }
-
-        if (_this9.messageHandler) {
-          _this9.messageHandler.destroy();
-
-          _this9.messageHandler = null;
-        }
-
-        _this9.destroyCapability.resolve();
-      }, this.destroyCapability.reject);
-      return this.destroyCapability.promise;
-    }
-  }, {
-    key: "setupMessageHandler",
-    value: function setupMessageHandler() {
-      var messageHandler = this.messageHandler,
-          loadingTask = this.loadingTask;
-      messageHandler.on('GetReader', function (data, sink) {
-        var _this10 = this;
-
-        (0, _util.assert)(this._networkStream);
-        this._fullReader = this._networkStream.getFullReader();
-
-        this._fullReader.onProgress = function (evt) {
-          _this10._lastProgress = {
-            loaded: evt.loaded,
-            total: evt.total
-          };
-        };
-
-        sink.onPull = function () {
-          _this10._fullReader.read().then(function (_ref7) {
-            var value = _ref7.value,
-                done = _ref7.done;
-
-            if (done) {
-              sink.close();
-              return;
-            }
-
-            (0, _util.assert)((0, _util.isArrayBuffer)(value));
-            sink.enqueue(new Uint8Array(value), 1, [value]);
-          })["catch"](function (reason) {
-            sink.error(reason);
-          });
-        };
-
-        sink.onCancel = function (reason) {
-          _this10._fullReader.cancel(reason);
-        };
-      }, this);
-      messageHandler.on('ReaderHeadersReady', function (data) {
-        var _this11 = this;
-
-        var headersCapability = (0, _util.createPromiseCapability)();
-        var fullReader = this._fullReader;
-        fullReader.headersReady.then(function () {
-          if (!fullReader.isStreamingSupported || !fullReader.isRangeSupported) {
-            if (_this11._lastProgress && loadingTask.onProgress) {
-              loadingTask.onProgress(_this11._lastProgress);
-            }
-
-            fullReader.onProgress = function (evt) {
-              if (loadingTask.onProgress) {
-                loadingTask.onProgress({
-                  loaded: evt.loaded,
-                  total: evt.total
-                });
-              }
-            };
-          }
-
-          headersCapability.resolve({
-            isStreamingSupported: fullReader.isStreamingSupported,
-            isRangeSupported: fullReader.isRangeSupported,
-            contentLength: fullReader.contentLength
-          });
-        }, headersCapability.reject);
-        return headersCapability.promise;
-      }, this);
-      messageHandler.on('GetRangeReader', function (data, sink) {
-        (0, _util.assert)(this._networkStream);
-
-        var rangeReader = this._networkStream.getRangeReader(data.begin, data.end);
-
-        if (!rangeReader) {
-          sink.close();
-          return;
-        }
-
-        sink.onPull = function () {
-          rangeReader.read().then(function (_ref8) {
-            var value = _ref8.value,
-                done = _ref8.done;
-
-            if (done) {
-              sink.close();
-              return;
-            }
-
-            (0, _util.assert)((0, _util.isArrayBuffer)(value));
-            sink.enqueue(new Uint8Array(value), 1, [value]);
-          })["catch"](function (reason) {
-            sink.error(reason);
-          });
-        };
-
-        sink.onCancel = function (reason) {
-          rangeReader.cancel(reason);
-        };
-      }, this);
-      messageHandler.on('GetDoc', function (_ref9) {
-        var pdfInfo = _ref9.pdfInfo;
-        this._numPages = pdfInfo.numPages;
-
-        loadingTask._capability.resolve(new PDFDocumentProxy(pdfInfo, this));
-      }, this);
-      messageHandler.on('PasswordRequest', function (exception) {
-        var _this12 = this;
-
-        this._passwordCapability = (0, _util.createPromiseCapability)();
-
-        if (loadingTask.onPassword) {
-          var updatePassword = function updatePassword(password) {
-            _this12._passwordCapability.resolve({
-              password: password
-            });
-          };
-
-          try {
-            loadingTask.onPassword(updatePassword, exception.code);
-          } catch (ex) {
-            this._passwordCapability.reject(ex);
-          }
-        } else {
-          this._passwordCapability.reject(new _util.PasswordException(exception.message, exception.code));
-        }
-
-        return this._passwordCapability.promise;
-      }, this);
-      messageHandler.on('PasswordException', function (exception) {
-        loadingTask._capability.reject(new _util.PasswordException(exception.message, exception.code));
-      }, this);
-      messageHandler.on('InvalidPDF', function (exception) {
-        loadingTask._capability.reject(new _util.InvalidPDFException(exception.message));
-      }, this);
-      messageHandler.on('MissingPDF', function (exception) {
-        loadingTask._capability.reject(new _util.MissingPDFException(exception.message));
-      }, this);
-      messageHandler.on('UnexpectedResponse', function (exception) {
-        loadingTask._capability.reject(new _util.UnexpectedResponseException(exception.message, exception.status));
-      }, this);
-      messageHandler.on('UnknownError', function (exception) {
-        loadingTask._capability.reject(new _util.UnknownErrorException(exception.message, exception.details));
-      }, this);
-      messageHandler.on('DataLoaded', function (data) {
-        if (loadingTask.onProgress) {
-          loadingTask.onProgress({
-            loaded: data.length,
-            total: data.length
-          });
-        }
-
-        this.downloadInfoCapability.resolve(data);
-      }, this);
-      messageHandler.on('StartRenderPage', function (data) {
-        if (this.destroyed) {
-          return;
-        }
-
-        var page = this.pageCache[data.pageIndex];
-
-        page._stats.timeEnd('Page Request');
-
-        page._startRenderPage(data.transparency, data.intent);
-      }, this);
-      messageHandler.on('RenderPageChunk', function (data) {
-        if (this.destroyed) {
-          return;
-        }
-
-        var page = this.pageCache[data.pageIndex];
-
-        page._renderPageChunk(data.operatorList, data.intent);
-      }, this);
-      messageHandler.on('commonobj', function (data) {
-        var _this13 = this;
-
-        if (this.destroyed) {
-          return;
-        }
-
-        var _data = _slicedToArray(data, 3),
-            id = _data[0],
-            type = _data[1],
-            exportedData = _data[2];
-
-        if (this.commonObjs.has(id)) {
-          return;
-        }
-
-        switch (type) {
-          case 'Font':
-            var params = this._params;
-
-            if ('error' in exportedData) {
-              var exportedError = exportedData.error;
-              (0, _util.warn)("Error during font loading: ".concat(exportedError));
-              this.commonObjs.resolve(id, exportedError);
-              break;
-            }
-
-            var fontRegistry = null;
-
-            if (params.pdfBug && _global_scope["default"].FontInspector && _global_scope["default"].FontInspector.enabled) {
-              fontRegistry = {
-                registerFont: function registerFont(font, url) {
-                  _global_scope["default"]['FontInspector'].fontAdded(font, url);
-                }
-              };
-            }
-
-            var font = new _font_loader.FontFaceObject(exportedData, {
-              isEvalSupported: params.isEvalSupported,
-              disableFontFace: params.disableFontFace,
-              ignoreErrors: params.ignoreErrors,
-              onUnsupportedFeature: this._onUnsupportedFeature.bind(this),
-              fontRegistry: fontRegistry
-            });
-            this.fontLoader.bind(font).then(function () {
-              _this13.commonObjs.resolve(id, font);
-            }, function (reason) {
-              messageHandler.sendWithPromise('FontFallback', {
-                id: id
-              })["finally"](function () {
-                _this13.commonObjs.resolve(id, font);
-              });
-            });
-            break;
-
-          case 'FontPath':
-          case 'FontType3Res':
-            this.commonObjs.resolve(id, exportedData);
-            break;
-
-          default:
-            throw new Error("Got unknown common object type ".concat(type));
-        }
-      }, this);
-      messageHandler.on('obj', function (data) {
-        if (this.destroyed) {
-          return undefined;
-        }
-
-        var _data2 = _slicedToArray(data, 4),
-            id = _data2[0],
-            pageIndex = _data2[1],
-            type = _data2[2],
-            imageData = _data2[3];
-
-        var pageProxy = this.pageCache[pageIndex];
-
-        if (pageProxy.objs.has(id)) {
-          return undefined;
-        }
-
-        switch (type) {
-          case 'JpegStream':
-            return new Promise(function (resolve, reject) {
-              var img = new Image();
-
-              img.onload = function () {
-                resolve(img);
-              };
-
-              img.onerror = function () {
-                reject(new Error('Error during JPEG image loading'));
-                (0, _display_utils.releaseImageResources)(img);
-              };
-
-              img.src = imageData;
-            }).then(function (img) {
-              pageProxy.objs.resolve(id, img);
-            });
-
-          case 'Image':
-            pageProxy.objs.resolve(id, imageData);
-            var MAX_IMAGE_SIZE_TO_STORE = 8000000;
-
-            if (imageData && 'data' in imageData && imageData.data.length > MAX_IMAGE_SIZE_TO_STORE) {
-              pageProxy.cleanupAfterRender = true;
-            }
-
-            break;
-
-          default:
-            throw new Error("Got unknown object type ".concat(type));
-        }
-
-        return undefined;
-      }, this);
-      messageHandler.on('DocProgress', function (data) {
-        if (this.destroyed) {
-          return;
-        }
-
-        if (loadingTask.onProgress) {
-          loadingTask.onProgress({
-            loaded: data.loaded,
-            total: data.total
-          });
-        }
-      }, this);
-      messageHandler.on('PageError', function (data) {
-        if (this.destroyed) {
-          return;
-        }
-
-        var page = this.pageCache[data.pageIndex];
-        var intentState = page.intentStates[data.intent];
-
-        if (intentState.displayReadyCapability) {
-          intentState.displayReadyCapability.reject(new Error(data.error));
-        } else {
-          throw new Error(data.error);
-        }
-
-        if (intentState.operatorList) {
-          intentState.operatorList.lastChunk = true;
-
-          for (var i = 0; i < intentState.renderTasks.length; i++) {
-            intentState.renderTasks[i].operatorListChanged();
-          }
-        }
-      }, this);
-      messageHandler.on('UnsupportedFeature', this._onUnsupportedFeature, this);
-      messageHandler.on('JpegDecode', function (data) {
-        if (this.destroyed) {
-          return Promise.reject(new Error('Worker was destroyed'));
-        }
-
-        if (typeof document === 'undefined') {
-          return Promise.reject(new Error('"document" is not defined.'));
-        }
-
-        var _data3 = _slicedToArray(data, 2),
-            imageUrl = _data3[0],
-            components = _data3[1];
-
-        if (components !== 3 && components !== 1) {
-          return Promise.reject(new Error('Only 3 components or 1 component can be returned'));
-        }
-
-        return new Promise(function (resolve, reject) {
-          var img = new Image();
-
-          img.onload = function () {
-            var width = img.width,
-                height = img.height;
-            var size = width * height;
-            var rgbaLength = size * 4;
-            var buf = new Uint8ClampedArray(size * components);
-            var tmpCanvas = document.createElement('canvas');
-            tmpCanvas.width = width;
-            tmpCanvas.height = height;
-            var tmpCtx = tmpCanvas.getContext('2d');
-            tmpCtx.drawImage(img, 0, 0);
-            var data = tmpCtx.getImageData(0, 0, width, height).data;
-
-            if (components === 3) {
-              for (var i = 0, j = 0; i < rgbaLength; i += 4, j += 3) {
-                buf[j] = data[i];
-                buf[j + 1] = data[i + 1];
-                buf[j + 2] = data[i + 2];
-              }
-            } else if (components === 1) {
-              for (var _i2 = 0, _j = 0; _i2 < rgbaLength; _i2 += 4, _j++) {
-                buf[_j] = data[_i2];
-              }
-            }
-
-            resolve({
-              data: buf,
-              width: width,
-              height: height
-            });
-            (0, _display_utils.releaseImageResources)(img);
-            tmpCanvas.width = 0;
-            tmpCanvas.height = 0;
-            tmpCanvas = null;
-            tmpCtx = null;
-          };
-
-          img.onerror = function () {
-            reject(new Error('JpegDecode failed to load image'));
-            (0, _display_utils.releaseImageResources)(img);
-          };
-
-          img.src = imageUrl;
-        });
-      }, this);
-      messageHandler.on('FetchBuiltInCMap', function (data) {
-        if (this.destroyed) {
-          return Promise.reject(new Error('Worker was destroyed'));
-        }
-
-        return this.CMapReaderFactory.fetch({
-          name: data.name
-        });
-      }, this);
-    }
-  }, {
-    key: "_onUnsupportedFeature",
-    value: function _onUnsupportedFeature(_ref10) {
-      var featureId = _ref10.featureId;
-
-      if (this.destroyed) {
-        return;
-      }
-
-      if (this.loadingTask.onUnsupportedFeature) {
-        this.loadingTask.onUnsupportedFeature(featureId);
-      }
-    }
-  }, {
-    key: "getData",
-    value: function getData() {
-      return this.messageHandler.sendWithPromise('GetData', null);
-    }
-  }, {
-    key: "getPage",
-    value: function getPage(pageNumber) {
-      var _this14 = this;
-
-      if (!Number.isInteger(pageNumber) || pageNumber <= 0 || pageNumber > this._numPages) {
-        return Promise.reject(new Error('Invalid page request'));
-      }
-
-      var pageIndex = pageNumber - 1;
-
-      if (pageIndex in this.pagePromises) {
-        return this.pagePromises[pageIndex];
-      }
-
-      var promise = this.messageHandler.sendWithPromise('GetPage', {
-        pageIndex: pageIndex
-      }).then(function (pageInfo) {
-        if (_this14.destroyed) {
-          throw new Error('Transport destroyed');
-        }
-
-        var page = new PDFPageProxy(pageIndex, pageInfo, _this14, _this14._params.pdfBug);
-        _this14.pageCache[pageIndex] = page;
-        return page;
-      });
-      this.pagePromises[pageIndex] = promise;
-      return promise;
-    }
-  }, {
-    key: "getPageIndex",
-    value: function getPageIndex(ref) {
-      return this.messageHandler.sendWithPromise('GetPageIndex', {
-        ref: ref
-      })["catch"](function (reason) {
-        return Promise.reject(new Error(reason));
-      });
-    }
-  }, {
-    key: "getAnnotations",
-    value: function getAnnotations(pageIndex, intent) {
-      return this.messageHandler.sendWithPromise('GetAnnotations', {
-        pageIndex: pageIndex,
-        intent: intent
-      });
-    }
-  }, {
-    key: "getDestinations",
-    value: function getDestinations() {
-      return this.messageHandler.sendWithPromise('GetDestinations', null);
-    }
-  }, {
-    key: "getDestination",
-    value: function getDestination(id) {
-      if (typeof id !== 'string') {
-        return Promise.reject(new Error('Invalid destination request.'));
-      }
-
-      return this.messageHandler.sendWithPromise('GetDestination', {
-        id: id
-      });
-    }
-  }, {
-    key: "getPageLabels",
-    value: function getPageLabels() {
-      return this.messageHandler.sendWithPromise('GetPageLabels', null);
-    }
-  }, {
-    key: "getPageLayout",
-    value: function getPageLayout() {
-      return this.messageHandler.sendWithPromise('GetPageLayout', null);
-    }
-  }, {
-    key: "getPageMode",
-    value: function getPageMode() {
-      return this.messageHandler.sendWithPromise('GetPageMode', null);
-    }
-  }, {
-    key: "getViewerPreferences",
-    value: function getViewerPreferences() {
-      return this.messageHandler.sendWithPromise('GetViewerPreferences', null);
-    }
-  }, {
-    key: "getOpenActionDestination",
-    value: function getOpenActionDestination() {
-      return this.messageHandler.sendWithPromise('GetOpenActionDestination', null);
-    }
-  }, {
-    key: "getAttachments",
-    value: function getAttachments() {
-      return this.messageHandler.sendWithPromise('GetAttachments', null);
-    }
-  }, {
-    key: "getJavaScript",
-    value: function getJavaScript() {
-      return this.messageHandler.sendWithPromise('GetJavaScript', null);
-    }
-  }, {
-    key: "getOutline",
-    value: function getOutline() {
-      return this.messageHandler.sendWithPromise('GetOutline', null);
-    }
-  }, {
-    key: "getPermissions",
-    value: function getPermissions() {
-      return this.messageHandler.sendWithPromise('GetPermissions', null);
-    }
-  }, {
-    key: "getMetadata",
-    value: function getMetadata() {
-      var _this15 = this;
-
-      return this.messageHandler.sendWithPromise('GetMetadata', null).then(function (results) {
-        return {
-          info: results[0],
-          metadata: results[1] ? new _metadata.Metadata(results[1]) : null,
-          contentDispositionFilename: _this15._fullReader ? _this15._fullReader.filename : null
-        };
-      });
-    }
-  }, {
-    key: "getStats",
-    value: function getStats() {
-      return this.messageHandler.sendWithPromise('GetStats', null);
-    }
-  }, {
-    key: "startCleanup",
-    value: function startCleanup() {
-      var _this16 = this;
-
-      this.messageHandler.sendWithPromise('Cleanup', null).then(function () {
-        for (var i = 0, ii = _this16.pageCache.length; i < ii; i++) {
-          var page = _this16.pageCache[i];
-
-          if (page) {
-            page.cleanup();
-          }
-        }
-
-        _this16.commonObjs.clear();
-
-        _this16.fontLoader.clear();
-      });
-    }
-  }, {
-    key: "loadingParams",
-    get: function get() {
-      var params = this._params;
-      return (0, _util.shadow)(this, 'loadingParams', {
-        disableAutoFetch: params.disableAutoFetch,
-        disableCreateObjectURL: params.disableCreateObjectURL,
-        disableFontFace: params.disableFontFace,
-        nativeImageDecoderSupport: params.nativeImageDecoderSupport
-      });
-    }
-  }]);
-
-  return WorkerTransport;
-}();
-
-var PDFObjects =
-/*#__PURE__*/
-function () {
-  function PDFObjects() {
-    _classCallCheck(this, PDFObjects);
-
-    this._objs = Object.create(null);
-  }
-
-  _createClass(PDFObjects, [{
-    key: "_ensureObj",
-    value: function _ensureObj(objId) {
-      if (this._objs[objId]) {
-        return this._objs[objId];
-      }
-
-      return this._objs[objId] = {
-        capability: (0, _util.createPromiseCapability)(),
-        data: null,
-        resolved: false
-      };
-    }
-  }, {
-    key: "get",
-    value: function get(objId) {
-      var callback = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
-
-      if (callback) {
-        this._ensureObj(objId).capability.promise.then(callback);
-
-        return null;
-      }
-
-      var obj = this._objs[objId];
-
-      if (!obj || !obj.resolved) {
-        throw new Error("Requesting object that isn't resolved yet ".concat(objId, "."));
-      }
-
-      return obj.data;
-    }
-  }, {
-    key: "has",
-    value: function has(objId) {
-      var obj = this._objs[objId];
-      return obj ? obj.resolved : false;
-    }
-  }, {
-    key: "resolve",
-    value: function resolve(objId, data) {
-      var obj = this._ensureObj(objId);
-
-      obj.resolved = true;
-      obj.data = data;
-      obj.capability.resolve(data);
-    }
-  }, {
-    key: "clear",
-    value: function clear() {
-      for (var objId in this._objs) {
-        var data = this._objs[objId].data;
-
-        if (typeof Image !== 'undefined' && data instanceof Image) {
-          (0, _display_utils.releaseImageResources)(data);
-        }
-      }
-
-      this._objs = Object.create(null);
-    }
-  }]);
-
-  return PDFObjects;
-}();
-
-var RenderTask =
-/*#__PURE__*/
-function () {
-  function RenderTask(internalRenderTask) {
-    _classCallCheck(this, RenderTask);
-
-    this._internalRenderTask = internalRenderTask;
-    this.onContinue = null;
-  }
-
-  _createClass(RenderTask, [{
-    key: "cancel",
-    value: function cancel() {
-      this._internalRenderTask.cancel();
-    }
-  }, {
-    key: "then",
-    value: function then(onFulfilled, onRejected) {
-      (0, _display_utils.deprecated)('RenderTask.then method, use the `promise` getter instead.');
-      return this.promise.then.apply(this.promise, arguments);
-    }
-  }, {
-    key: "promise",
-    get: function get() {
-      return this._internalRenderTask.capability.promise;
-    }
-  }]);
-
-  return RenderTask;
-}();
-
-var InternalRenderTask = function InternalRenderTaskClosure() {
-  var canvasInRendering = new WeakSet();
-
-  var InternalRenderTask =
-  /*#__PURE__*/
-  function () {
-    function InternalRenderTask(_ref11) {
-      var callback = _ref11.callback,
-          params = _ref11.params,
-          objs = _ref11.objs,
-          commonObjs = _ref11.commonObjs,
-          operatorList = _ref11.operatorList,
-          pageNumber = _ref11.pageNumber,
-          canvasFactory = _ref11.canvasFactory,
-          webGLContext = _ref11.webGLContext,
-          _ref11$useRequestAnim = _ref11.useRequestAnimationFrame,
-          useRequestAnimationFrame = _ref11$useRequestAnim === void 0 ? false : _ref11$useRequestAnim,
-          _ref11$pdfBug = _ref11.pdfBug,
-          pdfBug = _ref11$pdfBug === void 0 ? false : _ref11$pdfBug;
-
-      _classCallCheck(this, InternalRenderTask);
-
-      this.callback = callback;
-      this.params = params;
-      this.objs = objs;
-      this.commonObjs = commonObjs;
-      this.operatorListIdx = null;
-      this.operatorList = operatorList;
-      this.pageNumber = pageNumber;
-      this.canvasFactory = canvasFactory;
-      this.webGLContext = webGLContext;
-      this._pdfBug = pdfBug;
-      this.running = false;
-      this.graphicsReadyCallback = null;
-      this.graphicsReady = false;
-      this._useRequestAnimationFrame = useRequestAnimationFrame === true && typeof window !== 'undefined';
-      this.cancelled = false;
-      this.capability = (0, _util.createPromiseCapability)();
-      this.task = new RenderTask(this);
-      this._continueBound = this._continue.bind(this);
-      this._scheduleNextBound = this._scheduleNext.bind(this);
-      this._nextBound = this._next.bind(this);
-      this._canvas = params.canvasContext.canvas;
-    }
-
-    _createClass(InternalRenderTask, [{
-      key: "initializeGraphics",
-      value: function initializeGraphics() {
-        var transparency = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-
-        if (this.cancelled) {
-          return;
-        }
-
-        if (this._canvas) {
-          if (canvasInRendering.has(this._canvas)) {
-            throw new Error('Cannot use the same canvas during multiple render() operations. ' + 'Use different canvas or ensure previous operations were ' + 'cancelled or completed.');
-          }
-
-          canvasInRendering.add(this._canvas);
-        }
-
-        if (this._pdfBug && _global_scope["default"].StepperManager && _global_scope["default"].StepperManager.enabled) {
-          this.stepper = _global_scope["default"].StepperManager.create(this.pageNumber - 1);
-          this.stepper.init(this.operatorList);
-          this.stepper.nextBreakPoint = this.stepper.getNextBreakPoint();
-        }
-
-        var _this$params = this.params,
-            canvasContext = _this$params.canvasContext,
-            viewport = _this$params.viewport,
-            transform = _this$params.transform,
-            imageLayer = _this$params.imageLayer,
-            background = _this$params.background;
-        this.gfx = new _canvas.CanvasGraphics(canvasContext, this.commonObjs, this.objs, this.canvasFactory, this.webGLContext, imageLayer);
-        this.gfx.beginDrawing({
-          transform: transform,
-          viewport: viewport,
-          transparency: transparency,
-          background: background
-        });
-        this.operatorListIdx = 0;
-        this.graphicsReady = true;
-
-        if (this.graphicsReadyCallback) {
-          this.graphicsReadyCallback();
-        }
-      }
-    }, {
-      key: "cancel",
-      value: function cancel() {
-        var error = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
-        this.running = false;
-        this.cancelled = true;
-
-        if (this.gfx) {
-          this.gfx.endDrawing();
-        }
-
-        if (this._canvas) {
-          canvasInRendering["delete"](this._canvas);
-        }
-
-        this.callback(error || new _display_utils.RenderingCancelledException("Rendering cancelled, page ".concat(this.pageNumber), 'canvas'));
-      }
-    }, {
-      key: "operatorListChanged",
-      value: function operatorListChanged() {
-        if (!this.graphicsReady) {
-          if (!this.graphicsReadyCallback) {
-            this.graphicsReadyCallback = this._continueBound;
-          }
-
-          return;
-        }
-
-        if (this.stepper) {
-          this.stepper.updateOperatorList(this.operatorList);
-        }
-
-        if (this.running) {
-          return;
-        }
-
-        this._continue();
-      }
-    }, {
-      key: "_continue",
-      value: function _continue() {
-        this.running = true;
-
-        if (this.cancelled) {
-          return;
-        }
-
-        if (this.task.onContinue) {
-          this.task.onContinue(this._scheduleNextBound);
-        } else {
-          this._scheduleNext();
-        }
-      }
-    }, {
-      key: "_scheduleNext",
-      value: function _scheduleNext() {
-        var _this17 = this;
-
-        if (this._useRequestAnimationFrame) {
-          window.requestAnimationFrame(function () {
-            _this17._nextBound()["catch"](_this17.cancel.bind(_this17));
-          });
-        } else {
-          Promise.resolve().then(this._nextBound)["catch"](this.cancel.bind(this));
-        }
-      }
-    }, {
-      key: "_next",
-      value: function () {
-        var _next2 = _asyncToGenerator(
-        /*#__PURE__*/
-        _regenerator["default"].mark(function _callee() {
-          return _regenerator["default"].wrap(function _callee$(_context) {
-            while (1) {
-              switch (_context.prev = _context.next) {
-                case 0:
-                  if (!this.cancelled) {
-                    _context.next = 2;
-                    break;
-                  }
-
-                  return _context.abrupt("return");
-
-                case 2:
-                  this.operatorListIdx = this.gfx.executeOperatorList(this.operatorList, this.operatorListIdx, this._continueBound, this.stepper);
-
-                  if (this.operatorListIdx === this.operatorList.argsArray.length) {
-                    this.running = false;
-
-                    if (this.operatorList.lastChunk) {
-                      this.gfx.endDrawing();
-
-                      if (this._canvas) {
-                        canvasInRendering["delete"](this._canvas);
-                      }
-
-                      this.callback();
-                    }
-                  }
-
-                case 4:
-                case "end":
-                  return _context.stop();
-              }
-            }
-          }, _callee, this);
-        }));
-
-        function _next() {
-          return _next2.apply(this, arguments);
-        }
-
-        return _next;
-      }()
-    }]);
-
-    return InternalRenderTask;
-  }();
-
-  return InternalRenderTask;
-}();
-
-var version = '2.2.230';
-exports.version = version;
-var build = '6d118ec35';
-exports.build = build;
-
-/***/ }),
-/* 148 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-module.exports = __w_pdfjs_require__(149);
-
-/***/ }),
-/* 149 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-/* WEBPACK VAR INJECTION */(function(module) {
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-var runtime = function (exports) {
-  "use strict";
-
-  var Op = Object.prototype;
-  var hasOwn = Op.hasOwnProperty;
-  var undefined;
-  var $Symbol = typeof Symbol === "function" ? Symbol : {};
-  var iteratorSymbol = $Symbol.iterator || "@@iterator";
-  var asyncIteratorSymbol = $Symbol.asyncIterator || "@@asyncIterator";
-  var toStringTagSymbol = $Symbol.toStringTag || "@@toStringTag";
-
-  function wrap(innerFn, outerFn, self, tryLocsList) {
-    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator;
-    var generator = Object.create(protoGenerator.prototype);
-    var context = new Context(tryLocsList || []);
-    generator._invoke = makeInvokeMethod(innerFn, self, context);
-    return generator;
-  }
-
-  exports.wrap = wrap;
-
-  function tryCatch(fn, obj, arg) {
-    try {
-      return {
-        type: "normal",
-        arg: fn.call(obj, arg)
-      };
-    } catch (err) {
-      return {
-        type: "throw",
-        arg: err
-      };
-    }
-  }
-
-  var GenStateSuspendedStart = "suspendedStart";
-  var GenStateSuspendedYield = "suspendedYield";
-  var GenStateExecuting = "executing";
-  var GenStateCompleted = "completed";
-  var ContinueSentinel = {};
-
-  function Generator() {}
-
-  function GeneratorFunction() {}
-
-  function GeneratorFunctionPrototype() {}
-
-  var IteratorPrototype = {};
-
-  IteratorPrototype[iteratorSymbol] = function () {
-    return this;
-  };
-
-  var getProto = Object.getPrototypeOf;
-  var NativeIteratorPrototype = getProto && getProto(getProto(values([])));
-
-  if (NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol)) {
-    IteratorPrototype = NativeIteratorPrototype;
-  }
-
-  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);
-  GeneratorFunction.prototype = Gp.constructor = GeneratorFunctionPrototype;
-  GeneratorFunctionPrototype.constructor = GeneratorFunction;
-  GeneratorFunctionPrototype[toStringTagSymbol] = GeneratorFunction.displayName = "GeneratorFunction";
-
-  function defineIteratorMethods(prototype) {
-    ["next", "throw", "return"].forEach(function (method) {
-      prototype[method] = function (arg) {
-        return this._invoke(method, arg);
-      };
-    });
-  }
-
-  exports.isGeneratorFunction = function (genFun) {
-    var ctor = typeof genFun === "function" && genFun.constructor;
-    return ctor ? ctor === GeneratorFunction || (ctor.displayName || ctor.name) === "GeneratorFunction" : false;
-  };
-
-  exports.mark = function (genFun) {
-    if (Object.setPrototypeOf) {
-      Object.setPrototypeOf(genFun, GeneratorFunctionPrototype);
-    } else {
-      genFun.__proto__ = GeneratorFunctionPrototype;
-
-      if (!(toStringTagSymbol in genFun)) {
-        genFun[toStringTagSymbol] = "GeneratorFunction";
-      }
-    }
-
-    genFun.prototype = Object.create(Gp);
-    return genFun;
-  };
-
-  exports.awrap = function (arg) {
-    return {
-      __await: arg
-    };
-  };
-
-  function AsyncIterator(generator) {
-    function invoke(method, arg, resolve, reject) {
-      var record = tryCatch(generator[method], generator, arg);
-
-      if (record.type === "throw") {
-        reject(record.arg);
-      } else {
-        var result = record.arg;
-        var value = result.value;
-
-        if (value && _typeof(value) === "object" && hasOwn.call(value, "__await")) {
-          return Promise.resolve(value.__await).then(function (value) {
-            invoke("next", value, resolve, reject);
-          }, function (err) {
-            invoke("throw", err, resolve, reject);
-          });
-        }
-
-        return Promise.resolve(value).then(function (unwrapped) {
-          result.value = unwrapped;
-          resolve(result);
-        }, function (error) {
-          return invoke("throw", error, resolve, reject);
-        });
-      }
-    }
-
-    var previousPromise;
-
-    function enqueue(method, arg) {
-      function callInvokeWithMethodAndArg() {
-        return new Promise(function (resolve, reject) {
-          invoke(method, arg, resolve, reject);
-        });
-      }
-
-      return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
-    }
-
-    this._invoke = enqueue;
-  }
-
-  defineIteratorMethods(AsyncIterator.prototype);
-
-  AsyncIterator.prototype[asyncIteratorSymbol] = function () {
-    return this;
-  };
-
-  exports.AsyncIterator = AsyncIterator;
-
-  exports.async = function (innerFn, outerFn, self, tryLocsList) {
-    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList));
-    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {
-      return result.done ? result.value : iter.next();
-    });
-  };
-
-  function makeInvokeMethod(innerFn, self, context) {
-    var state = GenStateSuspendedStart;
-    return function invoke(method, arg) {
-      if (state === GenStateExecuting) {
-        throw new Error("Generator is already running");
-      }
-
-      if (state === GenStateCompleted) {
-        if (method === "throw") {
-          throw arg;
-        }
-
-        return doneResult();
-      }
-
-      context.method = method;
-      context.arg = arg;
-
-      while (true) {
-        var delegate = context.delegate;
-
-        if (delegate) {
-          var delegateResult = maybeInvokeDelegate(delegate, context);
-
-          if (delegateResult) {
-            if (delegateResult === ContinueSentinel) continue;
-            return delegateResult;
-          }
-        }
-
-        if (context.method === "next") {
-          context.sent = context._sent = context.arg;
-        } else if (context.method === "throw") {
-          if (state === GenStateSuspendedStart) {
-            state = GenStateCompleted;
-            throw context.arg;
-          }
-
-          context.dispatchException(context.arg);
-        } else if (context.method === "return") {
-          context.abrupt("return", context.arg);
-        }
-
-        state = GenStateExecuting;
-        var record = tryCatch(innerFn, self, context);
-
-        if (record.type === "normal") {
-          state = context.done ? GenStateCompleted : GenStateSuspendedYield;
-
-          if (record.arg === ContinueSentinel) {
-            continue;
-          }
-
-          return {
-            value: record.arg,
-            done: context.done
-          };
-        } else if (record.type === "throw") {
-          state = GenStateCompleted;
-          context.method = "throw";
-          context.arg = record.arg;
-        }
-      }
-    };
-  }
-
-  function maybeInvokeDelegate(delegate, context) {
-    var method = delegate.iterator[context.method];
-
-    if (method === undefined) {
-      context.delegate = null;
-
-      if (context.method === "throw") {
-        if (delegate.iterator["return"]) {
-          context.method = "return";
-          context.arg = undefined;
-          maybeInvokeDelegate(delegate, context);
-
-          if (context.method === "throw") {
-            return ContinueSentinel;
-          }
-        }
-
-        context.method = "throw";
-        context.arg = new TypeError("The iterator does not provide a 'throw' method");
-      }
-
-      return ContinueSentinel;
-    }
-
-    var record = tryCatch(method, delegate.iterator, context.arg);
-
-    if (record.type === "throw") {
-      context.method = "throw";
-      context.arg = record.arg;
-      context.delegate = null;
-      return ContinueSentinel;
-    }
-
-    var info = record.arg;
-
-    if (!info) {
-      context.method = "throw";
-      context.arg = new TypeError("iterator result is not an object");
-      context.delegate = null;
-      return ContinueSentinel;
-    }
-
-    if (info.done) {
-      context[delegate.resultName] = info.value;
-      context.next = delegate.nextLoc;
-
-      if (context.method !== "return") {
-        context.method = "next";
-        context.arg = undefined;
-      }
-    } else {
-      return info;
-    }
-
-    context.delegate = null;
-    return ContinueSentinel;
-  }
-
-  defineIteratorMethods(Gp);
-  Gp[toStringTagSymbol] = "Generator";
-
-  Gp[iteratorSymbol] = function () {
-    return this;
-  };
-
-  Gp.toString = function () {
-    return "[object Generator]";
-  };
-
-  function pushTryEntry(locs) {
-    var entry = {
-      tryLoc: locs[0]
-    };
-
-    if (1 in locs) {
-      entry.catchLoc = locs[1];
-    }
-
-    if (2 in locs) {
-      entry.finallyLoc = locs[2];
-      entry.afterLoc = locs[3];
-    }
-
-    this.tryEntries.push(entry);
-  }
-
-  function resetTryEntry(entry) {
-    var record = entry.completion || {};
-    record.type = "normal";
-    delete record.arg;
-    entry.completion = record;
-  }
-
-  function Context(tryLocsList) {
-    this.tryEntries = [{
-      tryLoc: "root"
-    }];
-    tryLocsList.forEach(pushTryEntry, this);
-    this.reset(true);
-  }
-
-  exports.keys = function (object) {
-    var keys = [];
-
-    for (var key in object) {
-      keys.push(key);
-    }
-
-    keys.reverse();
-    return function next() {
-      while (keys.length) {
-        var key = keys.pop();
-
-        if (key in object) {
-          next.value = key;
-          next.done = false;
-          return next;
-        }
-      }
-
-      next.done = true;
-      return next;
-    };
-  };
-
-  function values(iterable) {
-    if (iterable) {
-      var iteratorMethod = iterable[iteratorSymbol];
-
-      if (iteratorMethod) {
-        return iteratorMethod.call(iterable);
-      }
-
-      if (typeof iterable.next === "function") {
-        return iterable;
-      }
-
-      if (!isNaN(iterable.length)) {
-        var i = -1,
-            next = function next() {
-          while (++i < iterable.length) {
-            if (hasOwn.call(iterable, i)) {
-              next.value = iterable[i];
-              next.done = false;
-              return next;
-            }
-          }
-
-          next.value = undefined;
-          next.done = true;
-          return next;
-        };
-
-        return next.next = next;
-      }
-    }
-
-    return {
-      next: doneResult
-    };
-  }
-
-  exports.values = values;
-
-  function doneResult() {
-    return {
-      value: undefined,
-      done: true
-    };
-  }
-
-  Context.prototype = {
-    constructor: Context,
-    reset: function reset(skipTempReset) {
-      this.prev = 0;
-      this.next = 0;
-      this.sent = this._sent = undefined;
-      this.done = false;
-      this.delegate = null;
-      this.method = "next";
-      this.arg = undefined;
-      this.tryEntries.forEach(resetTryEntry);
-
-      if (!skipTempReset) {
-        for (var name in this) {
-          if (name.charAt(0) === "t" && hasOwn.call(this, name) && !isNaN(+name.slice(1))) {
-            this[name] = undefined;
-          }
-        }
-      }
-    },
-    stop: function stop() {
-      this.done = true;
-      var rootEntry = this.tryEntries[0];
-      var rootRecord = rootEntry.completion;
-
-      if (rootRecord.type === "throw") {
-        throw rootRecord.arg;
-      }
-
-      return this.rval;
-    },
-    dispatchException: function dispatchException(exception) {
-      if (this.done) {
-        throw exception;
-      }
-
-      var context = this;
-
-      function handle(loc, caught) {
-        record.type = "throw";
-        record.arg = exception;
-        context.next = loc;
-
-        if (caught) {
-          context.method = "next";
-          context.arg = undefined;
-        }
-
-        return !!caught;
-      }
-
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-        var record = entry.completion;
-
-        if (entry.tryLoc === "root") {
-          return handle("end");
-        }
-
-        if (entry.tryLoc <= this.prev) {
-          var hasCatch = hasOwn.call(entry, "catchLoc");
-          var hasFinally = hasOwn.call(entry, "finallyLoc");
-
-          if (hasCatch && hasFinally) {
-            if (this.prev < entry.catchLoc) {
-              return handle(entry.catchLoc, true);
-            } else if (this.prev < entry.finallyLoc) {
-              return handle(entry.finallyLoc);
-            }
-          } else if (hasCatch) {
-            if (this.prev < entry.catchLoc) {
-              return handle(entry.catchLoc, true);
-            }
-          } else if (hasFinally) {
-            if (this.prev < entry.finallyLoc) {
-              return handle(entry.finallyLoc);
-            }
-          } else {
-            throw new Error("try statement without catch or finally");
-          }
-        }
-      }
-    },
-    abrupt: function abrupt(type, arg) {
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-
-        if (entry.tryLoc <= this.prev && hasOwn.call(entry, "finallyLoc") && this.prev < entry.finallyLoc) {
-          var finallyEntry = entry;
-          break;
-        }
-      }
-
-      if (finallyEntry && (type === "break" || type === "continue") && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc) {
-        finallyEntry = null;
-      }
-
-      var record = finallyEntry ? finallyEntry.completion : {};
-      record.type = type;
-      record.arg = arg;
-
-      if (finallyEntry) {
-        this.method = "next";
-        this.next = finallyEntry.finallyLoc;
-        return ContinueSentinel;
-      }
-
-      return this.complete(record);
-    },
-    complete: function complete(record, afterLoc) {
-      if (record.type === "throw") {
-        throw record.arg;
-      }
-
-      if (record.type === "break" || record.type === "continue") {
-        this.next = record.arg;
-      } else if (record.type === "return") {
-        this.rval = this.arg = record.arg;
-        this.method = "return";
-        this.next = "end";
-      } else if (record.type === "normal" && afterLoc) {
-        this.next = afterLoc;
-      }
-
-      return ContinueSentinel;
-    },
-    finish: function finish(finallyLoc) {
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-
-        if (entry.finallyLoc === finallyLoc) {
-          this.complete(entry.completion, entry.afterLoc);
-          resetTryEntry(entry);
-          return ContinueSentinel;
-        }
-      }
-    },
-    "catch": function _catch(tryLoc) {
-      for (var i = this.tryEntries.length - 1; i >= 0; --i) {
-        var entry = this.tryEntries[i];
-
-        if (entry.tryLoc === tryLoc) {
-          var record = entry.completion;
-
-          if (record.type === "throw") {
-            var thrown = record.arg;
-            resetTryEntry(entry);
-          }
-
-          return thrown;
-        }
-      }
-
-      throw new Error("illegal catch attempt");
-    },
-    delegateYield: function delegateYield(iterable, resultName, nextLoc) {
-      this.delegate = {
-        iterator: values(iterable),
-        resultName: resultName,
-        nextLoc: nextLoc
-      };
-
-      if (this.method === "next") {
-        this.arg = undefined;
-      }
-
-      return ContinueSentinel;
-    }
-  };
-  return exports;
-}(( false ? undefined : _typeof(module)) === "object" ? module.exports : {});
-
-try {
-  regeneratorRuntime = runtime;
-} catch (accidentalStrictMode) {
-  Function("r", "regeneratorRuntime = r")(runtime);
-}
-/* WEBPACK VAR INJECTION */}.call(this, __w_pdfjs_require__(150)(module)))
-
-/***/ }),
-/* 150 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-module.exports = function (module) {
-  if (!module.webpackPolyfill) {
-    module.deprecate = function () {};
-
-    module.paths = [];
-    if (!module.children) module.children = [];
-    Object.defineProperty(module, "loaded", {
-      enumerable: true,
-      get: function get() {
-        return module.l;
-      }
-    });
-    Object.defineProperty(module, "id", {
-      enumerable: true,
-      get: function get() {
-        return module.i;
-      }
-    });
-    module.webpackPolyfill = 1;
-  }
-
-  return module;
-};
-
-/***/ }),
-/* 151 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.addLinkAttributes = addLinkAttributes;
-exports.getFilenameFromUrl = getFilenameFromUrl;
-exports.isFetchSupported = isFetchSupported;
-exports.isValidFetchUrl = isValidFetchUrl;
-exports.loadScript = loadScript;
-exports.deprecated = deprecated;
-exports.releaseImageResources = releaseImageResources;
-exports.PDFDateString = exports.DummyStatTimer = exports.StatTimer = exports.DOMSVGFactory = exports.DOMCMapReaderFactory = exports.DOMCanvasFactory = exports.DEFAULT_LINK_REL = exports.LinkTarget = exports.RenderingCancelledException = exports.PageViewport = void 0;
-
-var _regenerator = _interopRequireDefault(__w_pdfjs_require__(148));
-
-var _util = __w_pdfjs_require__(1);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-var DEFAULT_LINK_REL = 'noopener noreferrer nofollow';
-exports.DEFAULT_LINK_REL = DEFAULT_LINK_REL;
-var SVG_NS = 'http://www.w3.org/2000/svg';
-
-var DOMCanvasFactory =
-/*#__PURE__*/
-function () {
-  function DOMCanvasFactory() {
-    _classCallCheck(this, DOMCanvasFactory);
-  }
-
-  _createClass(DOMCanvasFactory, [{
-    key: "create",
-    value: function create(width, height) {
-      if (width <= 0 || height <= 0) {
-        throw new Error('Invalid canvas size');
-      }
-
-      var canvas = document.createElement('canvas');
-      var context = canvas.getContext('2d');
-      canvas.width = width;
-      canvas.height = height;
-      return {
-        canvas: canvas,
-        context: context
-      };
-    }
-  }, {
-    key: "reset",
-    value: function reset(canvasAndContext, width, height) {
-      if (!canvasAndContext.canvas) {
-        throw new Error('Canvas is not specified');
-      }
-
-      if (width <= 0 || height <= 0) {
-        throw new Error('Invalid canvas size');
-      }
-
-      canvasAndContext.canvas.width = width;
-      canvasAndContext.canvas.height = height;
-    }
-  }, {
-    key: "destroy",
-    value: function destroy(canvasAndContext) {
-      if (!canvasAndContext.canvas) {
-        throw new Error('Canvas is not specified');
-      }
-
-      canvasAndContext.canvas.width = 0;
-      canvasAndContext.canvas.height = 0;
-      canvasAndContext.canvas = null;
-      canvasAndContext.context = null;
-    }
-  }]);
-
-  return DOMCanvasFactory;
-}();
-
-exports.DOMCanvasFactory = DOMCanvasFactory;
-
-var DOMCMapReaderFactory =
-/*#__PURE__*/
-function () {
-  function DOMCMapReaderFactory(_ref) {
-    var _ref$baseUrl = _ref.baseUrl,
-        baseUrl = _ref$baseUrl === void 0 ? null : _ref$baseUrl,
-        _ref$isCompressed = _ref.isCompressed,
-        isCompressed = _ref$isCompressed === void 0 ? false : _ref$isCompressed;
-
-    _classCallCheck(this, DOMCMapReaderFactory);
-
-    this.baseUrl = baseUrl;
-    this.isCompressed = isCompressed;
-  }
-
-  _createClass(DOMCMapReaderFactory, [{
-    key: "fetch",
-    value: function (_fetch) {
-      function fetch(_x) {
-        return _fetch.apply(this, arguments);
-      }
-
-      fetch.toString = function () {
-        return _fetch.toString();
-      };
-
-      return fetch;
-    }(
-    /*#__PURE__*/
-    function () {
-      var _ref3 = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator["default"].mark(function _callee2(_ref2) {
-        var _this = this;
-
-        var name, url, compressionType;
-        return _regenerator["default"].wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                name = _ref2.name;
-
-                if (this.baseUrl) {
-                  _context2.next = 3;
-                  break;
-                }
-
-                throw new Error('The CMap "baseUrl" parameter must be specified, ensure that ' + 'the "cMapUrl" and "cMapPacked" API parameters are provided.');
-
-              case 3:
-                if (name) {
-                  _context2.next = 5;
-                  break;
-                }
-
-                throw new Error('CMap name must be specified.');
-
-              case 5:
-                url = this.baseUrl + name + (this.isCompressed ? '.bcmap' : '');
-                compressionType = this.isCompressed ? _util.CMapCompressionType.BINARY : _util.CMapCompressionType.NONE;
-
-                if (!(isFetchSupported() && isValidFetchUrl(url, document.baseURI))) {
-                  _context2.next = 9;
-                  break;
-                }
-
-                return _context2.abrupt("return", fetch(url).then(
-                /*#__PURE__*/
-                function () {
-                  var _ref4 = _asyncToGenerator(
-                  /*#__PURE__*/
-                  _regenerator["default"].mark(function _callee(response) {
-                    var cMapData;
-                    return _regenerator["default"].wrap(function _callee$(_context) {
-                      while (1) {
-                        switch (_context.prev = _context.next) {
-                          case 0:
-                            if (response.ok) {
-                              _context.next = 2;
-                              break;
-                            }
-
-                            throw new Error(response.statusText);
-
-                          case 2:
-                            if (!_this.isCompressed) {
-                              _context.next = 10;
-                              break;
-                            }
-
-                            _context.t0 = Uint8Array;
-                            _context.next = 6;
-                            return response.arrayBuffer();
-
-                          case 6:
-                            _context.t1 = _context.sent;
-                            cMapData = new _context.t0(_context.t1);
-                            _context.next = 15;
-                            break;
-
-                          case 10:
-                            _context.t2 = _util.stringToBytes;
-                            _context.next = 13;
-                            return response.text();
-
-                          case 13:
-                            _context.t3 = _context.sent;
-                            cMapData = (0, _context.t2)(_context.t3);
-
-                          case 15:
-                            return _context.abrupt("return", {
-                              cMapData: cMapData,
-                              compressionType: compressionType
-                            });
-
-                          case 16:
-                          case "end":
-                            return _context.stop();
-                        }
-                      }
-                    }, _callee);
-                  }));
-
-                  return function (_x3) {
-                    return _ref4.apply(this, arguments);
-                  };
-                }())["catch"](function (reason) {
-                  throw new Error("Unable to load ".concat(_this.isCompressed ? 'binary ' : '') + "CMap at: ".concat(url));
-                }));
-
-              case 9:
-                return _context2.abrupt("return", new Promise(function (resolve, reject) {
-                  var request = new XMLHttpRequest();
-                  request.open('GET', url, true);
-
-                  if (_this.isCompressed) {
-                    request.responseType = 'arraybuffer';
-                  }
-
-                  request.onreadystatechange = function () {
-                    if (request.readyState !== XMLHttpRequest.DONE) {
-                      return;
-                    }
-
-                    if (request.status === 200 || request.status === 0) {
-                      var cMapData;
-
-                      if (_this.isCompressed && request.response) {
-                        cMapData = new Uint8Array(request.response);
-                      } else if (!_this.isCompressed && request.responseText) {
-                        cMapData = (0, _util.stringToBytes)(request.responseText);
-                      }
-
-                      if (cMapData) {
-                        resolve({
-                          cMapData: cMapData,
-                          compressionType: compressionType
-                        });
-                        return;
-                      }
-                    }
-
-                    reject(new Error(request.statusText));
-                  };
-
-                  request.send(null);
-                })["catch"](function (reason) {
-                  throw new Error("Unable to load ".concat(_this.isCompressed ? 'binary ' : '') + "CMap at: ".concat(url));
-                }));
-
-              case 10:
-              case "end":
-                return _context2.stop();
-            }
-          }
-        }, _callee2, this);
-      }));
-
-      return function (_x2) {
-        return _ref3.apply(this, arguments);
-      };
-    }())
-  }]);
-
-  return DOMCMapReaderFactory;
-}();
-
-exports.DOMCMapReaderFactory = DOMCMapReaderFactory;
-
-var DOMSVGFactory =
-/*#__PURE__*/
-function () {
-  function DOMSVGFactory() {
-    _classCallCheck(this, DOMSVGFactory);
-  }
-
-  _createClass(DOMSVGFactory, [{
-    key: "create",
-    value: function create(width, height) {
-      (0, _util.assert)(width > 0 && height > 0, 'Invalid SVG dimensions');
-      var svg = document.createElementNS(SVG_NS, 'svg:svg');
-      svg.setAttribute('version', '1.1');
-      svg.setAttribute('width', width + 'px');
-      svg.setAttribute('height', height + 'px');
-      svg.setAttribute('preserveAspectRatio', 'none');
-      svg.setAttribute('viewBox', '0 0 ' + width + ' ' + height);
-      return svg;
-    }
-  }, {
-    key: "createElement",
-    value: function createElement(type) {
-      (0, _util.assert)(typeof type === 'string', 'Invalid SVG element type');
-      return document.createElementNS(SVG_NS, type);
-    }
-  }]);
-
-  return DOMSVGFactory;
-}();
-
-exports.DOMSVGFactory = DOMSVGFactory;
-
-var PageViewport =
-/*#__PURE__*/
-function () {
-  function PageViewport(_ref5) {
-    var viewBox = _ref5.viewBox,
-        scale = _ref5.scale,
-        rotation = _ref5.rotation,
-        _ref5$offsetX = _ref5.offsetX,
-        offsetX = _ref5$offsetX === void 0 ? 0 : _ref5$offsetX,
-        _ref5$offsetY = _ref5.offsetY,
-        offsetY = _ref5$offsetY === void 0 ? 0 : _ref5$offsetY,
-        _ref5$dontFlip = _ref5.dontFlip,
-        dontFlip = _ref5$dontFlip === void 0 ? false : _ref5$dontFlip;
-
-    _classCallCheck(this, PageViewport);
-
-    this.viewBox = viewBox;
-    this.scale = scale;
-    this.rotation = rotation;
-    this.offsetX = offsetX;
-    this.offsetY = offsetY;
-    var centerX = (viewBox[2] + viewBox[0]) / 2;
-    var centerY = (viewBox[3] + viewBox[1]) / 2;
-    var rotateA, rotateB, rotateC, rotateD;
-    rotation = rotation % 360;
-    rotation = rotation < 0 ? rotation + 360 : rotation;
-
-    switch (rotation) {
-      case 180:
-        rotateA = -1;
-        rotateB = 0;
-        rotateC = 0;
-        rotateD = 1;
-        break;
-
-      case 90:
-        rotateA = 0;
-        rotateB = 1;
-        rotateC = 1;
-        rotateD = 0;
-        break;
-
-      case 270:
-        rotateA = 0;
-        rotateB = -1;
-        rotateC = -1;
-        rotateD = 0;
-        break;
-
-      default:
-        rotateA = 1;
-        rotateB = 0;
-        rotateC = 0;
-        rotateD = -1;
-        break;
-    }
-
-    if (dontFlip) {
-      rotateC = -rotateC;
-      rotateD = -rotateD;
-    }
-
-    var offsetCanvasX, offsetCanvasY;
-    var width, height;
-
-    if (rotateA === 0) {
-      offsetCanvasX = Math.abs(centerY - viewBox[1]) * scale + offsetX;
-      offsetCanvasY = Math.abs(centerX - viewBox[0]) * scale + offsetY;
-      width = Math.abs(viewBox[3] - viewBox[1]) * scale;
-      height = Math.abs(viewBox[2] - viewBox[0]) * scale;
-    } else {
-      offsetCanvasX = Math.abs(centerX - viewBox[0]) * scale + offsetX;
-      offsetCanvasY = Math.abs(centerY - viewBox[1]) * scale + offsetY;
-      width = Math.abs(viewBox[2] - viewBox[0]) * scale;
-      height = Math.abs(viewBox[3] - viewBox[1]) * scale;
-    }
-
-    this.transform = [rotateA * scale, rotateB * scale, rotateC * scale, rotateD * scale, offsetCanvasX - rotateA * scale * centerX - rotateC * scale * centerY, offsetCanvasY - rotateB * scale * centerX - rotateD * scale * centerY];
-    this.width = width;
-    this.height = height;
-  }
-
-  _createClass(PageViewport, [{
-    key: "clone",
-    value: function clone() {
-      var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
-          _ref6$scale = _ref6.scale,
-          scale = _ref6$scale === void 0 ? this.scale : _ref6$scale,
-          _ref6$rotation = _ref6.rotation,
-          rotation = _ref6$rotation === void 0 ? this.rotation : _ref6$rotation,
-          _ref6$dontFlip = _ref6.dontFlip,
-          dontFlip = _ref6$dontFlip === void 0 ? false : _ref6$dontFlip;
-
-      return new PageViewport({
-        viewBox: this.viewBox.slice(),
-        scale: scale,
-        rotation: rotation,
-        offsetX: this.offsetX,
-        offsetY: this.offsetY,
-        dontFlip: dontFlip
-      });
-    }
-  }, {
-    key: "convertToViewportPoint",
-    value: function convertToViewportPoint(x, y) {
-      return _util.Util.applyTransform([x, y], this.transform);
-    }
-  }, {
-    key: "convertToViewportRectangle",
-    value: function convertToViewportRectangle(rect) {
-      var topLeft = _util.Util.applyTransform([rect[0], rect[1]], this.transform);
-
-      var bottomRight = _util.Util.applyTransform([rect[2], rect[3]], this.transform);
-
-      return [topLeft[0], topLeft[1], bottomRight[0], bottomRight[1]];
-    }
-  }, {
-    key: "convertToPdfPoint",
-    value: function convertToPdfPoint(x, y) {
-      return _util.Util.applyInverseTransform([x, y], this.transform);
-    }
-  }]);
-
-  return PageViewport;
-}();
-
-exports.PageViewport = PageViewport;
-
-var RenderingCancelledException = function RenderingCancelledException() {
-  function RenderingCancelledException(msg, type) {
-    this.message = msg;
-    this.type = type;
-  }
-
-  RenderingCancelledException.prototype = new Error();
-  RenderingCancelledException.prototype.name = 'RenderingCancelledException';
-  RenderingCancelledException.constructor = RenderingCancelledException;
-  return RenderingCancelledException;
-}();
-
-exports.RenderingCancelledException = RenderingCancelledException;
-var LinkTarget = {
-  NONE: 0,
-  SELF: 1,
-  BLANK: 2,
-  PARENT: 3,
-  TOP: 4
-};
-exports.LinkTarget = LinkTarget;
-var LinkTargetStringMap = ['', '_self', '_blank', '_parent', '_top'];
-
-function addLinkAttributes(link) {
-  var _ref7 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},
-      url = _ref7.url,
-      target = _ref7.target,
-      rel = _ref7.rel;
-
-  link.href = link.title = url ? (0, _util.removeNullCharacters)(url) : '';
-
-  if (url) {
-    var LinkTargetValues = Object.values(LinkTarget);
-    var targetIndex = LinkTargetValues.includes(target) ? target : LinkTarget.NONE;
-    link.target = LinkTargetStringMap[targetIndex];
-    link.rel = typeof rel === 'string' ? rel : DEFAULT_LINK_REL;
-  }
-}
-
-function getFilenameFromUrl(url) {
-  var anchor = url.indexOf('#');
-  var query = url.indexOf('?');
-  var end = Math.min(anchor > 0 ? anchor : url.length, query > 0 ? query : url.length);
-  return url.substring(url.lastIndexOf('/', end) + 1, end);
-}
-
-var StatTimer =
-/*#__PURE__*/
-function () {
-  function StatTimer() {
-    var enable = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-
-    _classCallCheck(this, StatTimer);
-
-    this.enabled = !!enable;
-    this.started = Object.create(null);
-    this.times = [];
-  }
-
-  _createClass(StatTimer, [{
-    key: "time",
-    value: function time(name) {
-      if (!this.enabled) {
-        return;
-      }
-
-      if (name in this.started) {
-        (0, _util.warn)('Timer is already running for ' + name);
-      }
-
-      this.started[name] = Date.now();
-    }
-  }, {
-    key: "timeEnd",
-    value: function timeEnd(name) {
-      if (!this.enabled) {
-        return;
-      }
-
-      if (!(name in this.started)) {
-        (0, _util.warn)('Timer has not been started for ' + name);
-      }
-
-      this.times.push({
-        'name': name,
-        'start': this.started[name],
-        'end': Date.now()
-      });
-      delete this.started[name];
-    }
-  }, {
-    key: "toString",
-    value: function toString() {
-      var out = '',
-          longest = 0;
-      var _iteratorNormalCompletion = true;
-      var _didIteratorError = false;
-      var _iteratorError = undefined;
-
-      try {
-        for (var _iterator = this.times[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-          var time = _step.value;
-          var name = time.name;
-
-          if (name.length > longest) {
-            longest = name.length;
-          }
-        }
-      } catch (err) {
-        _didIteratorError = true;
-        _iteratorError = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion && _iterator["return"] != null) {
-            _iterator["return"]();
-          }
-        } finally {
-          if (_didIteratorError) {
-            throw _iteratorError;
-          }
-        }
-      }
-
-      var _iteratorNormalCompletion2 = true;
-      var _didIteratorError2 = false;
-      var _iteratorError2 = undefined;
-
-      try {
-        for (var _iterator2 = this.times[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-          var _time = _step2.value;
-          var duration = _time.end - _time.start;
-          out += "".concat(_time.name.padEnd(longest), " ").concat(duration, "ms\n");
-        }
-      } catch (err) {
-        _didIteratorError2 = true;
-        _iteratorError2 = err;
-      } finally {
-        try {
-          if (!_iteratorNormalCompletion2 && _iterator2["return"] != null) {
-            _iterator2["return"]();
-          }
-        } finally {
-          if (_didIteratorError2) {
-            throw _iteratorError2;
-          }
-        }
-      }
-
-      return out;
-    }
-  }]);
-
-  return StatTimer;
-}();
-
-exports.StatTimer = StatTimer;
-
-var DummyStatTimer =
-/*#__PURE__*/
-function () {
-  function DummyStatTimer() {
-    _classCallCheck(this, DummyStatTimer);
-
-    (0, _util.unreachable)('Cannot initialize DummyStatTimer.');
-  }
-
-  _createClass(DummyStatTimer, null, [{
-    key: "time",
-    value: function time(name) {}
-  }, {
-    key: "timeEnd",
-    value: function timeEnd(name) {}
-  }, {
-    key: "toString",
-    value: function toString() {
-      return '';
-    }
-  }]);
-
-  return DummyStatTimer;
-}();
-
-exports.DummyStatTimer = DummyStatTimer;
-
-function isFetchSupported() {
-  return typeof fetch !== 'undefined' && typeof Response !== 'undefined' && 'body' in Response.prototype && typeof ReadableStream !== 'undefined';
-}
-
-function isValidFetchUrl(url, baseUrl) {
-  try {
-    var _ref8 = baseUrl ? new _util.URL(url, baseUrl) : new _util.URL(url),
-        protocol = _ref8.protocol;
-
-    return protocol === 'http:' || protocol === 'https:';
-  } catch (ex) {
-    return false;
-  }
-}
-
-function loadScript(src) {
-  return new Promise(function (resolve, reject) {
-    var script = document.createElement('script');
-    script.src = src;
-    script.onload = resolve;
-
-    script.onerror = function () {
-      reject(new Error("Cannot load script at: ".concat(script.src)));
-    };
-
-    (document.head || document.documentElement).appendChild(script);
-  });
-}
-
-function deprecated(details) {
-  console.log('Deprecated API usage: ' + details);
-}
-
-function releaseImageResources(img) {
-  (0, _util.assert)(img instanceof Image, 'Invalid `img` parameter.');
-  var url = img.src;
-
-  if (typeof url === 'string' && url.startsWith('blob:') && _util.URL.revokeObjectURL) {
-    _util.URL.revokeObjectURL(url);
-  }
-
-  img.removeAttribute('src');
-}
-
-var pdfDateStringRegex;
-
-var PDFDateString =
-/*#__PURE__*/
-function () {
-  function PDFDateString() {
-    _classCallCheck(this, PDFDateString);
-  }
-
-  _createClass(PDFDateString, null, [{
-    key: "toDateObject",
-    value: function toDateObject(input) {
-      if (!input || !(0, _util.isString)(input)) {
-        return null;
-      }
-
-      if (!pdfDateStringRegex) {
-        pdfDateStringRegex = new RegExp('^D:' + '(\\d{4})' + '(\\d{2})?' + '(\\d{2})?' + '(\\d{2})?' + '(\\d{2})?' + '(\\d{2})?' + '([Z|+|-])?' + '(\\d{2})?' + '\'?' + '(\\d{2})?' + '\'?');
-      }
-
-      var matches = pdfDateStringRegex.exec(input);
-
-      if (!matches) {
-        return null;
-      }
-
-      var year = parseInt(matches[1], 10);
-      var month = parseInt(matches[2], 10);
-      month = month >= 1 && month <= 12 ? month - 1 : 0;
-      var day = parseInt(matches[3], 10);
-      day = day >= 1 && day <= 31 ? day : 1;
-      var hour = parseInt(matches[4], 10);
-      hour = hour >= 0 && hour <= 23 ? hour : 0;
-      var minute = parseInt(matches[5], 10);
-      minute = minute >= 0 && minute <= 59 ? minute : 0;
-      var second = parseInt(matches[6], 10);
-      second = second >= 0 && second <= 59 ? second : 0;
-      var universalTimeRelation = matches[7] || 'Z';
-      var offsetHour = parseInt(matches[8], 10);
-      offsetHour = offsetHour >= 0 && offsetHour <= 23 ? offsetHour : 0;
-      var offsetMinute = parseInt(matches[9], 10) || 0;
-      offsetMinute = offsetMinute >= 0 && offsetMinute <= 59 ? offsetMinute : 0;
-
-      if (universalTimeRelation === '-') {
-        hour += offsetHour;
-        minute += offsetMinute;
-      } else if (universalTimeRelation === '+') {
-        hour -= offsetHour;
-        minute -= offsetMinute;
-      }
-
-      return new Date(Date.UTC(year, month, day, hour, minute, second));
-    }
-  }]);
-
-  return PDFDateString;
-}();
-
-exports.PDFDateString = PDFDateString;
-
-/***/ }),
-/* 152 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.FontLoader = exports.FontFaceObject = void 0;
-
-var _regenerator = _interopRequireDefault(__w_pdfjs_require__(148));
-
-var _util = __w_pdfjs_require__(1);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-var BaseFontLoader =
-/*#__PURE__*/
-function () {
-  function BaseFontLoader(_ref) {
-    var docId = _ref.docId,
-        onUnsupportedFeature = _ref.onUnsupportedFeature;
-
-    _classCallCheck(this, BaseFontLoader);
-
-    if (this.constructor === BaseFontLoader) {
-      (0, _util.unreachable)('Cannot initialize BaseFontLoader.');
-    }
-
-    this.docId = docId;
-    this._onUnsupportedFeature = onUnsupportedFeature;
-    this.nativeFontFaces = [];
-    this.styleElement = null;
-  }
-
-  _createClass(BaseFontLoader, [{
-    key: "addNativeFontFace",
-    value: function addNativeFontFace(nativeFontFace) {
-      this.nativeFontFaces.push(nativeFontFace);
-      document.fonts.add(nativeFontFace);
-    }
-  }, {
-    key: "insertRule",
-    value: function insertRule(rule) {
-      var styleElement = this.styleElement;
-
-      if (!styleElement) {
-        styleElement = this.styleElement = document.createElement('style');
-        styleElement.id = "PDFJS_FONT_STYLE_TAG_".concat(this.docId);
-        document.documentElement.getElementsByTagName('head')[0].appendChild(styleElement);
-      }
-
-      var styleSheet = styleElement.sheet;
-      styleSheet.insertRule(rule, styleSheet.cssRules.length);
-    }
-  }, {
-    key: "clear",
-    value: function clear() {
-      this.nativeFontFaces.forEach(function (nativeFontFace) {
-        document.fonts["delete"](nativeFontFace);
-      });
-      this.nativeFontFaces.length = 0;
-
-      if (this.styleElement) {
-        this.styleElement.remove();
-        this.styleElement = null;
-      }
-    }
-  }, {
-    key: "bind",
-    value: function () {
-      var _bind = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator["default"].mark(function _callee(font) {
-        var _this = this;
-
-        var nativeFontFace, rule;
-        return _regenerator["default"].wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                if (!(font.attached || font.missingFile)) {
-                  _context.next = 2;
-                  break;
-                }
-
-                return _context.abrupt("return", undefined);
-
-              case 2:
-                font.attached = true;
-
-                if (!this.isFontLoadingAPISupported) {
-                  _context.next = 19;
-                  break;
-                }
-
-                nativeFontFace = font.createNativeFontFace();
-
-                if (!nativeFontFace) {
-                  _context.next = 18;
-                  break;
-                }
-
-                this.addNativeFontFace(nativeFontFace);
-                _context.prev = 7;
-                _context.next = 10;
-                return nativeFontFace.loaded;
-
-              case 10:
-                _context.next = 18;
-                break;
-
-              case 12:
-                _context.prev = 12;
-                _context.t0 = _context["catch"](7);
-
-                this._onUnsupportedFeature({
-                  featureId: _util.UNSUPPORTED_FEATURES.font
-                });
-
-                (0, _util.warn)("Failed to load font '".concat(nativeFontFace.family, "': '").concat(_context.t0, "'."));
-                font.disableFontFace = true;
-                throw _context.t0;
-
-              case 18:
-                return _context.abrupt("return", undefined);
-
-              case 19:
-                rule = font.createFontFaceRule();
-
-                if (!rule) {
-                  _context.next = 25;
-                  break;
-                }
-
-                this.insertRule(rule);
-
-                if (!this.isSyncFontLoadingSupported) {
-                  _context.next = 24;
-                  break;
-                }
-
-                return _context.abrupt("return", undefined);
-
-              case 24:
-                return _context.abrupt("return", new Promise(function (resolve) {
-                  var request = _this._queueLoadingCallback(resolve);
-
-                  _this._prepareFontLoadEvent([rule], [font], request);
-                }));
-
-              case 25:
-                return _context.abrupt("return", undefined);
-
-              case 26:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this, [[7, 12]]);
-      }));
-
-      function bind(_x) {
-        return _bind.apply(this, arguments);
-      }
-
-      return bind;
-    }()
-  }, {
-    key: "_queueLoadingCallback",
-    value: function _queueLoadingCallback(callback) {
-      (0, _util.unreachable)('Abstract method `_queueLoadingCallback`.');
-    }
-  }, {
-    key: "_prepareFontLoadEvent",
-    value: function _prepareFontLoadEvent(rules, fontsToLoad, request) {
-      (0, _util.unreachable)('Abstract method `_prepareFontLoadEvent`.');
-    }
-  }, {
-    key: "isFontLoadingAPISupported",
-    get: function get() {
-      (0, _util.unreachable)('Abstract method `isFontLoadingAPISupported`.');
-    }
-  }, {
-    key: "isSyncFontLoadingSupported",
-    get: function get() {
-      (0, _util.unreachable)('Abstract method `isSyncFontLoadingSupported`.');
-    }
-  }, {
-    key: "_loadTestFont",
-    get: function get() {
-      (0, _util.unreachable)('Abstract method `_loadTestFont`.');
-    }
-  }]);
-
-  return BaseFontLoader;
-}();
-
-var FontLoader;
-exports.FontLoader = FontLoader;
-{
-  exports.FontLoader = FontLoader =
-  /*#__PURE__*/
-  function (_BaseFontLoader) {
-    _inherits(GenericFontLoader, _BaseFontLoader);
-
-    function GenericFontLoader(docId) {
-      var _this2;
-
-      _classCallCheck(this, GenericFontLoader);
-
-      _this2 = _possibleConstructorReturn(this, _getPrototypeOf(GenericFontLoader).call(this, docId));
-      _this2.loadingContext = {
-        requests: [],
-        nextRequestId: 0
-      };
-      _this2.loadTestFontId = 0;
-      return _this2;
-    }
-
-    _createClass(GenericFontLoader, [{
-      key: "_queueLoadingCallback",
-      value: function _queueLoadingCallback(callback) {
-        function completeRequest() {
-          (0, _util.assert)(!request.done, 'completeRequest() cannot be called twice.');
-          request.done = true;
-
-          while (context.requests.length > 0 && context.requests[0].done) {
-            var otherRequest = context.requests.shift();
-            setTimeout(otherRequest.callback, 0);
-          }
-        }
-
-        var context = this.loadingContext;
-        var request = {
-          id: "pdfjs-font-loading-".concat(context.nextRequestId++),
-          done: false,
-          complete: completeRequest,
-          callback: callback
-        };
-        context.requests.push(request);
-        return request;
-      }
-    }, {
-      key: "_prepareFontLoadEvent",
-      value: function _prepareFontLoadEvent(rules, fonts, request) {
-        function int32(data, offset) {
-          return data.charCodeAt(offset) << 24 | data.charCodeAt(offset + 1) << 16 | data.charCodeAt(offset + 2) << 8 | data.charCodeAt(offset + 3) & 0xff;
-        }
-
-        function spliceString(s, offset, remove, insert) {
-          var chunk1 = s.substring(0, offset);
-          var chunk2 = s.substring(offset + remove);
-          return chunk1 + insert + chunk2;
-        }
-
-        var i, ii;
-        var canvas = document.createElement('canvas');
-        canvas.width = 1;
-        canvas.height = 1;
-        var ctx = canvas.getContext('2d');
-        var called = 0;
-
-        function isFontReady(name, callback) {
-          called++;
-
-          if (called > 30) {
-            (0, _util.warn)('Load test font never loaded.');
-            callback();
-            return;
-          }
-
-          ctx.font = '30px ' + name;
-          ctx.fillText('.', 0, 20);
-          var imageData = ctx.getImageData(0, 0, 1, 1);
-
-          if (imageData.data[3] > 0) {
-            callback();
-            return;
-          }
-
-          setTimeout(isFontReady.bind(null, name, callback));
-        }
-
-        var loadTestFontId = "lt".concat(Date.now()).concat(this.loadTestFontId++);
-        var data = this._loadTestFont;
-        var COMMENT_OFFSET = 976;
-        data = spliceString(data, COMMENT_OFFSET, loadTestFontId.length, loadTestFontId);
-        var CFF_CHECKSUM_OFFSET = 16;
-        var XXXX_VALUE = 0x58585858;
-        var checksum = int32(data, CFF_CHECKSUM_OFFSET);
-
-        for (i = 0, ii = loadTestFontId.length - 3; i < ii; i += 4) {
-          checksum = checksum - XXXX_VALUE + int32(loadTestFontId, i) | 0;
-        }
-
-        if (i < loadTestFontId.length) {
-          checksum = checksum - XXXX_VALUE + int32(loadTestFontId + 'XXX', i) | 0;
-        }
-
-        data = spliceString(data, CFF_CHECKSUM_OFFSET, 4, (0, _util.string32)(checksum));
-        var url = "url(data:font/opentype;base64,".concat(btoa(data), ");");
-        var rule = "@font-face {font-family:\"".concat(loadTestFontId, "\";src:").concat(url, "}");
-        this.insertRule(rule);
-        var names = [];
-
-        for (i = 0, ii = fonts.length; i < ii; i++) {
-          names.push(fonts[i].loadedName);
-        }
-
-        names.push(loadTestFontId);
-        var div = document.createElement('div');
-        div.setAttribute('style', 'visibility: hidden;' + 'width: 10px; height: 10px;' + 'position: absolute; top: 0px; left: 0px;');
-
-        for (i = 0, ii = names.length; i < ii; ++i) {
-          var span = document.createElement('span');
-          span.textContent = 'Hi';
-          span.style.fontFamily = names[i];
-          div.appendChild(span);
-        }
-
-        document.body.appendChild(div);
-        isFontReady(loadTestFontId, function () {
-          document.body.removeChild(div);
-          request.complete();
-        });
-      }
-    }, {
-      key: "isFontLoadingAPISupported",
-      get: function get() {
-        var supported = typeof document !== 'undefined' && !!document.fonts;
-
-        if (supported && typeof navigator !== 'undefined') {
-          var m = /Mozilla\/5.0.*?rv:(\d+).*? Gecko/.exec(navigator.userAgent);
-
-          if (m && m[1] < 63) {
-            supported = false;
-          }
-        }
-
-        return (0, _util.shadow)(this, 'isFontLoadingAPISupported', supported);
-      }
-    }, {
-      key: "isSyncFontLoadingSupported",
-      get: function get() {
-        var supported = false;
-
-        if (typeof navigator === 'undefined') {
-          supported = true;
-        } else {
-          var m = /Mozilla\/5.0.*?rv:(\d+).*? Gecko/.exec(navigator.userAgent);
-
-          if (m && m[1] >= 14) {
-            supported = true;
-          }
-        }
-
-        return (0, _util.shadow)(this, 'isSyncFontLoadingSupported', supported);
-      }
-    }, {
-      key: "_loadTestFont",
-      get: function get() {
-        var getLoadTestFont = function getLoadTestFont() {
-          return atob('T1RUTwALAIAAAwAwQ0ZGIDHtZg4AAAOYAAAAgUZGVE1lkzZwAAAEHAAAABxHREVGABQA' + 'FQAABDgAAAAeT1MvMlYNYwkAAAEgAAAAYGNtYXABDQLUAAACNAAAAUJoZWFk/xVFDQAA' + 'ALwAAAA2aGhlYQdkA+oAAAD0AAAAJGhtdHgD6AAAAAAEWAAAAAZtYXhwAAJQAAAAARgA' + 'AAAGbmFtZVjmdH4AAAGAAAAAsXBvc3T/hgAzAAADeAAAACAAAQAAAAEAALZRFsRfDzz1' + 'AAsD6AAAAADOBOTLAAAAAM4KHDwAAAAAA+gDIQAAAAgAAgAAAAAAAAABAAADIQAAAFoD' + '6AAAAAAD6AABAAAAAAAAAAAAAAAAAAAAAQAAUAAAAgAAAAQD6AH0AAUAAAKKArwAAACM' + 'AooCvAAAAeAAMQECAAACAAYJAAAAAAAAAAAAAQAAAAAAAAAAAAAAAFBmRWQAwAAuAC4D' + 'IP84AFoDIQAAAAAAAQAAAAAAAAAAACAAIAABAAAADgCuAAEAAAAAAAAAAQAAAAEAAAAA' + 'AAEAAQAAAAEAAAAAAAIAAQAAAAEAAAAAAAMAAQAAAAEAAAAAAAQAAQAAAAEAAAAAAAUA' + 'AQAAAAEAAAAAAAYAAQAAAAMAAQQJAAAAAgABAAMAAQQJAAEAAgABAAMAAQQJAAIAAgAB' + 'AAMAAQQJAAMAAgABAAMAAQQJAAQAAgABAAMAAQQJAAUAAgABAAMAAQQJAAYAAgABWABY' + 'AAAAAAAAAwAAAAMAAAAcAAEAAAAAADwAAwABAAAAHAAEACAAAAAEAAQAAQAAAC7//wAA' + 'AC7////TAAEAAAAAAAABBgAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' + 'AAAAAAAAAAAAAAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' + 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' + 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' + 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' + 'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAMAAAAAAAD/gwAyAAAAAQAAAAAAAAAAAAAAAAAA' + 'AAABAAQEAAEBAQJYAAEBASH4DwD4GwHEAvgcA/gXBIwMAYuL+nz5tQXkD5j3CBLnEQAC' + 'AQEBIVhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYAAABAQAADwACAQEEE/t3' + 'Dov6fAH6fAT+fPp8+nwHDosMCvm1Cvm1DAz6fBQAAAAAAAABAAAAAMmJbzEAAAAAzgTj' + 'FQAAAADOBOQpAAEAAAAAAAAADAAUAAQAAAABAAAAAgABAAAAAAAAAAAD6AAAAAAAAA==');
-        };
-
-        return (0, _util.shadow)(this, '_loadTestFont', getLoadTestFont());
-      }
-    }]);
-
-    return GenericFontLoader;
-  }(BaseFontLoader);
-}
-var IsEvalSupportedCached = {
-  get value() {
-    return (0, _util.shadow)(this, 'value', (0, _util.isEvalSupported)());
-  }
-
-};
-
-var FontFaceObject =
-/*#__PURE__*/
-function () {
-  function FontFaceObject(translatedData, _ref2) {
-    var _ref2$isEvalSupported = _ref2.isEvalSupported,
-        isEvalSupported = _ref2$isEvalSupported === void 0 ? true : _ref2$isEvalSupported,
-        _ref2$disableFontFace = _ref2.disableFontFace,
-        disableFontFace = _ref2$disableFontFace === void 0 ? false : _ref2$disableFontFace,
-        _ref2$ignoreErrors = _ref2.ignoreErrors,
-        ignoreErrors = _ref2$ignoreErrors === void 0 ? false : _ref2$ignoreErrors,
-        _ref2$onUnsupportedFe = _ref2.onUnsupportedFeature,
-        onUnsupportedFeature = _ref2$onUnsupportedFe === void 0 ? null : _ref2$onUnsupportedFe,
-        _ref2$fontRegistry = _ref2.fontRegistry,
-        fontRegistry = _ref2$fontRegistry === void 0 ? null : _ref2$fontRegistry;
-
-    _classCallCheck(this, FontFaceObject);
-
-    this.compiledGlyphs = Object.create(null);
-
-    for (var i in translatedData) {
-      this[i] = translatedData[i];
-    }
-
-    this.isEvalSupported = isEvalSupported !== false;
-    this.disableFontFace = disableFontFace === true;
-    this.ignoreErrors = ignoreErrors === true;
-    this._onUnsupportedFeature = onUnsupportedFeature;
-    this.fontRegistry = fontRegistry;
-  }
-
-  _createClass(FontFaceObject, [{
-    key: "createNativeFontFace",
-    value: function createNativeFontFace() {
-      if (!this.data || this.disableFontFace) {
-        return null;
-      }
-
-      var nativeFontFace = new FontFace(this.loadedName, this.data, {});
-
-      if (this.fontRegistry) {
-        this.fontRegistry.registerFont(this);
-      }
-
-      return nativeFontFace;
-    }
-  }, {
-    key: "createFontFaceRule",
-    value: function createFontFaceRule() {
-      if (!this.data || this.disableFontFace) {
-        return null;
-      }
-
-      var data = (0, _util.bytesToString)(new Uint8Array(this.data));
-      var url = "url(data:".concat(this.mimetype, ";base64,").concat(btoa(data), ");");
-      var rule = "@font-face {font-family:\"".concat(this.loadedName, "\";src:").concat(url, "}");
-
-      if (this.fontRegistry) {
-        this.fontRegistry.registerFont(this, url);
-      }
-
-      return rule;
-    }
-  }, {
-    key: "getPathGenerator",
-    value: function getPathGenerator(objs, character) {
-      if (this.compiledGlyphs[character] !== undefined) {
-        return this.compiledGlyphs[character];
-      }
-
-      var cmds, current;
-
-      try {
-        cmds = objs.get(this.loadedName + '_path_' + character);
-      } catch (ex) {
-        if (!this.ignoreErrors) {
-          throw ex;
-        }
-
-        if (this._onUnsupportedFeature) {
-          this._onUnsupportedFeature({
-            featureId: _util.UNSUPPORTED_FEATURES.font
-          });
-        }
-
-        (0, _util.warn)("getPathGenerator - ignoring character: \"".concat(ex, "\"."));
-        return this.compiledGlyphs[character] = function (c, size) {};
-      }
-
-      if (this.isEvalSupported && IsEvalSupportedCached.value) {
-        var args,
-            js = '';
-
-        for (var i = 0, ii = cmds.length; i < ii; i++) {
-          current = cmds[i];
-
-          if (current.args !== undefined) {
-            args = current.args.join(',');
-          } else {
-            args = '';
-          }
-
-          js += 'c.' + current.cmd + '(' + args + ');\n';
-        }
-
-        return this.compiledGlyphs[character] = new Function('c', 'size', js);
-      }
-
-      return this.compiledGlyphs[character] = function (c, size) {
-        for (var _i = 0, _ii = cmds.length; _i < _ii; _i++) {
-          current = cmds[_i];
-
-          if (current.cmd === 'scale') {
-            current.args = [size, -size];
-          }
-
-          c[current.cmd].apply(c, current.args);
-        }
-      };
-    }
-  }]);
-
-  return FontFaceObject;
-}();
-
-exports.FontFaceObject = FontFaceObject;
-
-/***/ }),
-/* 153 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-var compatibilityParams = Object.create(null);
-{
-  var isNodeJS = __w_pdfjs_require__(4);
-
-  var userAgent = typeof navigator !== 'undefined' && navigator.userAgent || '';
-  var isIE = /Trident/.test(userAgent);
-  var isIOSChrome = /CriOS/.test(userAgent);
-
-  (function checkOnBlobSupport() {
-    if (isIE || isIOSChrome) {
-      compatibilityParams.disableCreateObjectURL = true;
-    }
-  })();
-
-  (function checkFontFaceAndImage() {
-    if (isNodeJS()) {
-      compatibilityParams.disableFontFace = true;
-      compatibilityParams.nativeImageDecoderSupport = 'none';
-    }
-  })();
-}
-exports.apiCompatibilityParams = Object.freeze(compatibilityParams);
-
-/***/ }),
-/* 154 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.CanvasGraphics = void 0;
-
-var _util = __w_pdfjs_require__(1);
-
-var _pattern_helper = __w_pdfjs_require__(155);
-
-var MIN_FONT_SIZE = 16;
-var MAX_FONT_SIZE = 100;
-var MAX_GROUP_SIZE = 4096;
-var MIN_WIDTH_FACTOR = 0.65;
-var COMPILE_TYPE3_GLYPHS = true;
-var MAX_SIZE_TO_COMPILE = 1000;
-var FULL_CHUNK_HEIGHT = 16;
-var IsLittleEndianCached = {
-  get value() {
-    return (0, _util.shadow)(IsLittleEndianCached, 'value', (0, _util.isLittleEndian)());
-  }
-
-};
-
-function addContextCurrentTransform(ctx) {
-  if (!ctx.mozCurrentTransform) {
-    ctx._originalSave = ctx.save;
-    ctx._originalRestore = ctx.restore;
-    ctx._originalRotate = ctx.rotate;
-    ctx._originalScale = ctx.scale;
-    ctx._originalTranslate = ctx.translate;
-    ctx._originalTransform = ctx.transform;
-    ctx._originalSetTransform = ctx.setTransform;
-    ctx._transformMatrix = ctx._transformMatrix || [1, 0, 0, 1, 0, 0];
-    ctx._transformStack = [];
-    Object.defineProperty(ctx, 'mozCurrentTransform', {
-      get: function getCurrentTransform() {
-        return this._transformMatrix;
-      }
-    });
-    Object.defineProperty(ctx, 'mozCurrentTransformInverse', {
-      get: function getCurrentTransformInverse() {
-        var m = this._transformMatrix;
-        var a = m[0],
-            b = m[1],
-            c = m[2],
-            d = m[3],
-            e = m[4],
-            f = m[5];
-        var ad_bc = a * d - b * c;
-        var bc_ad = b * c - a * d;
-        return [d / ad_bc, b / bc_ad, c / bc_ad, a / ad_bc, (d * e - c * f) / bc_ad, (b * e - a * f) / ad_bc];
-      }
-    });
-
-    ctx.save = function ctxSave() {
-      var old = this._transformMatrix;
-
-      this._transformStack.push(old);
-
-      this._transformMatrix = old.slice(0, 6);
-
-      this._originalSave();
-    };
-
-    ctx.restore = function ctxRestore() {
-      var prev = this._transformStack.pop();
-
-      if (prev) {
-        this._transformMatrix = prev;
-
-        this._originalRestore();
-      }
-    };
-
-    ctx.translate = function ctxTranslate(x, y) {
-      var m = this._transformMatrix;
-      m[4] = m[0] * x + m[2] * y + m[4];
-      m[5] = m[1] * x + m[3] * y + m[5];
-
-      this._originalTranslate(x, y);
-    };
-
-    ctx.scale = function ctxScale(x, y) {
-      var m = this._transformMatrix;
-      m[0] = m[0] * x;
-      m[1] = m[1] * x;
-      m[2] = m[2] * y;
-      m[3] = m[3] * y;
-
-      this._originalScale(x, y);
-    };
-
-    ctx.transform = function ctxTransform(a, b, c, d, e, f) {
-      var m = this._transformMatrix;
-      this._transformMatrix = [m[0] * a + m[2] * b, m[1] * a + m[3] * b, m[0] * c + m[2] * d, m[1] * c + m[3] * d, m[0] * e + m[2] * f + m[4], m[1] * e + m[3] * f + m[5]];
-
-      ctx._originalTransform(a, b, c, d, e, f);
-    };
-
-    ctx.setTransform = function ctxSetTransform(a, b, c, d, e, f) {
-      this._transformMatrix = [a, b, c, d, e, f];
-
-      ctx._originalSetTransform(a, b, c, d, e, f);
-    };
-
-    ctx.rotate = function ctxRotate(angle) {
-      var cosValue = Math.cos(angle);
-      var sinValue = Math.sin(angle);
-      var m = this._transformMatrix;
-      this._transformMatrix = [m[0] * cosValue + m[2] * sinValue, m[1] * cosValue + m[3] * sinValue, m[0] * -sinValue + m[2] * cosValue, m[1] * -sinValue + m[3] * cosValue, m[4], m[5]];
-
-      this._originalRotate(angle);
-    };
-  }
-}
-
-var CachedCanvases = function CachedCanvasesClosure() {
-  function CachedCanvases(canvasFactory) {
-    this.canvasFactory = canvasFactory;
-    this.cache = Object.create(null);
-  }
-
-  CachedCanvases.prototype = {
-    getCanvas: function CachedCanvases_getCanvas(id, width, height, trackTransform) {
-      var canvasEntry;
-
-      if (this.cache[id] !== undefined) {
-        canvasEntry = this.cache[id];
-        this.canvasFactory.reset(canvasEntry, width, height);
-        canvasEntry.context.setTransform(1, 0, 0, 1, 0, 0);
-      } else {
-        canvasEntry = this.canvasFactory.create(width, height);
-        this.cache[id] = canvasEntry;
-      }
-
-      if (trackTransform) {
-        addContextCurrentTransform(canvasEntry.context);
-      }
-
-      return canvasEntry;
-    },
-    clear: function clear() {
-      for (var id in this.cache) {
-        var canvasEntry = this.cache[id];
-        this.canvasFactory.destroy(canvasEntry);
-        delete this.cache[id];
-      }
-    }
-  };
-  return CachedCanvases;
-}();
-
-function compileType3Glyph(imgData) {
-  var POINT_TO_PROCESS_LIMIT = 1000;
-  var width = imgData.width,
-      height = imgData.height;
-  var i,
-      j,
-      j0,
-      width1 = width + 1;
-  var points = new Uint8Array(width1 * (height + 1));
-  var POINT_TYPES = new Uint8Array([0, 2, 4, 0, 1, 0, 5, 4, 8, 10, 0, 8, 0, 2, 1, 0]);
-  var lineSize = width + 7 & ~7,
-      data0 = imgData.data;
-  var data = new Uint8Array(lineSize * height),
-      pos = 0,
-      ii;
-
-  for (i = 0, ii = data0.length; i < ii; i++) {
-    var mask = 128,
-        elem = data0[i];
-
-    while (mask > 0) {
-      data[pos++] = elem & mask ? 0 : 255;
-      mask >>= 1;
-    }
-  }
-
-  var count = 0;
-  pos = 0;
-
-  if (data[pos] !== 0) {
-    points[0] = 1;
-    ++count;
-  }
-
-  for (j = 1; j < width; j++) {
-    if (data[pos] !== data[pos + 1]) {
-      points[j] = data[pos] ? 2 : 1;
-      ++count;
-    }
-
-    pos++;
-  }
-
-  if (data[pos] !== 0) {
-    points[j] = 2;
-    ++count;
-  }
-
-  for (i = 1; i < height; i++) {
-    pos = i * lineSize;
-    j0 = i * width1;
-
-    if (data[pos - lineSize] !== data[pos]) {
-      points[j0] = data[pos] ? 1 : 8;
-      ++count;
-    }
-
-    var sum = (data[pos] ? 4 : 0) + (data[pos - lineSize] ? 8 : 0);
-
-    for (j = 1; j < width; j++) {
-      sum = (sum >> 2) + (data[pos + 1] ? 4 : 0) + (data[pos - lineSize + 1] ? 8 : 0);
-
-      if (POINT_TYPES[sum]) {
-        points[j0 + j] = POINT_TYPES[sum];
-        ++count;
-      }
-
-      pos++;
-    }
-
-    if (data[pos - lineSize] !== data[pos]) {
-      points[j0 + j] = data[pos] ? 2 : 4;
-      ++count;
-    }
-
-    if (count > POINT_TO_PROCESS_LIMIT) {
-      return null;
-    }
-  }
-
-  pos = lineSize * (height - 1);
-  j0 = i * width1;
-
-  if (data[pos] !== 0) {
-    points[j0] = 8;
-    ++count;
-  }
-
-  for (j = 1; j < width; j++) {
-    if (data[pos] !== data[pos + 1]) {
-      points[j0 + j] = data[pos] ? 4 : 8;
-      ++count;
-    }
-
-    pos++;
-  }
-
-  if (data[pos] !== 0) {
-    points[j0 + j] = 4;
-    ++count;
-  }
-
-  if (count > POINT_TO_PROCESS_LIMIT) {
-    return null;
-  }
-
-  var steps = new Int32Array([0, width1, -1, 0, -width1, 0, 0, 0, 1]);
-  var outlines = [];
-
-  for (i = 0; count && i <= height; i++) {
-    var p = i * width1;
-    var end = p + width;
-
-    while (p < end && !points[p]) {
-      p++;
-    }
-
-    if (p === end) {
-      continue;
-    }
-
-    var coords = [p % width1, i];
-    var type = points[p],
-        p0 = p,
-        pp;
-
-    do {
-      var step = steps[type];
-
-      do {
-        p += step;
-      } while (!points[p]);
-
-      pp = points[p];
-
-      if (pp !== 5 && pp !== 10) {
-        type = pp;
-        points[p] = 0;
-      } else {
-        type = pp & 0x33 * type >> 4;
-        points[p] &= type >> 2 | type << 2;
-      }
-
-      coords.push(p % width1);
-      coords.push(p / width1 | 0);
-
-      if (!points[p]) {
-        --count;
-      }
-    } while (p0 !== p);
-
-    outlines.push(coords);
-    --i;
-  }
-
-  var drawOutline = function drawOutline(c) {
-    c.save();
-    c.scale(1 / width, -1 / height);
-    c.translate(0, -height);
-    c.beginPath();
-
-    for (var i = 0, ii = outlines.length; i < ii; i++) {
-      var o = outlines[i];
-      c.moveTo(o[0], o[1]);
-
-      for (var j = 2, jj = o.length; j < jj; j += 2) {
-        c.lineTo(o[j], o[j + 1]);
-      }
-    }
-
-    c.fill();
-    c.beginPath();
-    c.restore();
-  };
-
-  return drawOutline;
-}
-
-var CanvasExtraState = function CanvasExtraStateClosure() {
-  function CanvasExtraState() {
-    this.alphaIsShape = false;
-    this.fontSize = 0;
-    this.fontSizeScale = 1;
-    this.textMatrix = _util.IDENTITY_MATRIX;
-    this.textMatrixScale = 1;
-    this.fontMatrix = _util.FONT_IDENTITY_MATRIX;
-    this.leading = 0;
-    this.x = 0;
-    this.y = 0;
-    this.lineX = 0;
-    this.lineY = 0;
-    this.charSpacing = 0;
-    this.wordSpacing = 0;
-    this.textHScale = 1;
-    this.textRenderingMode = _util.TextRenderingMode.FILL;
-    this.textRise = 0;
-    this.fillColor = '#000000';
-    this.strokeColor = '#000000';
-    this.patternFill = false;
-    this.fillAlpha = 1;
-    this.strokeAlpha = 1;
-    this.lineWidth = 1;
-    this.activeSMask = null;
-    this.resumeSMaskCtx = null;
-  }
-
-  CanvasExtraState.prototype = {
-    clone: function CanvasExtraState_clone() {
-      return Object.create(this);
-    },
-    setCurrentPoint: function CanvasExtraState_setCurrentPoint(x, y) {
-      this.x = x;
-      this.y = y;
-    }
-  };
-  return CanvasExtraState;
-}();
-
-var CanvasGraphics = function CanvasGraphicsClosure() {
-  var EXECUTION_TIME = 15;
-  var EXECUTION_STEPS = 10;
-
-  function CanvasGraphics(canvasCtx, commonObjs, objs, canvasFactory, webGLContext, imageLayer) {
-    this.ctx = canvasCtx;
-    this.current = new CanvasExtraState();
-    this.stateStack = [];
-    this.pendingClip = null;
-    this.pendingEOFill = false;
-    this.res = null;
-    this.xobjs = null;
-    this.commonObjs = commonObjs;
-    this.objs = objs;
-    this.canvasFactory = canvasFactory;
-    this.webGLContext = webGLContext;
-    this.imageLayer = imageLayer;
-    this.groupStack = [];
-    this.processingType3 = null;
-    this.baseTransform = null;
-    this.baseTransformStack = [];
-    this.groupLevel = 0;
-    this.smaskStack = [];
-    this.smaskCounter = 0;
-    this.tempSMask = null;
-    this.cachedCanvases = new CachedCanvases(this.canvasFactory);
-
-    if (canvasCtx) {
-      addContextCurrentTransform(canvasCtx);
-    }
-
-    this._cachedGetSinglePixelWidth = null;
-  }
-
-  function putBinaryImageData(ctx, imgData) {
-    if (typeof ImageData !== 'undefined' && imgData instanceof ImageData) {
-      ctx.putImageData(imgData, 0, 0);
-      return;
-    }
-
-    var height = imgData.height,
-        width = imgData.width;
-    var partialChunkHeight = height % FULL_CHUNK_HEIGHT;
-    var fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;
-    var totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;
-    var chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);
-    var srcPos = 0,
-        destPos;
-    var src = imgData.data;
-    var dest = chunkImgData.data;
-    var i, j, thisChunkHeight, elemsInThisChunk;
-
-    if (imgData.kind === _util.ImageKind.GRAYSCALE_1BPP) {
-      var srcLength = src.byteLength;
-      var dest32 = new Uint32Array(dest.buffer, 0, dest.byteLength >> 2);
-      var dest32DataLength = dest32.length;
-      var fullSrcDiff = width + 7 >> 3;
-      var white = 0xFFFFFFFF;
-      var black = IsLittleEndianCached.value ? 0xFF000000 : 0x000000FF;
-
-      for (i = 0; i < totalChunks; i++) {
-        thisChunkHeight = i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight;
-        destPos = 0;
-
-        for (j = 0; j < thisChunkHeight; j++) {
-          var srcDiff = srcLength - srcPos;
-          var k = 0;
-          var kEnd = srcDiff > fullSrcDiff ? width : srcDiff * 8 - 7;
-          var kEndUnrolled = kEnd & ~7;
-          var mask = 0;
-          var srcByte = 0;
-
-          for (; k < kEndUnrolled; k += 8) {
-            srcByte = src[srcPos++];
-            dest32[destPos++] = srcByte & 128 ? white : black;
-            dest32[destPos++] = srcByte & 64 ? white : black;
-            dest32[destPos++] = srcByte & 32 ? white : black;
-            dest32[destPos++] = srcByte & 16 ? white : black;
-            dest32[destPos++] = srcByte & 8 ? white : black;
-            dest32[destPos++] = srcByte & 4 ? white : black;
-            dest32[destPos++] = srcByte & 2 ? white : black;
-            dest32[destPos++] = srcByte & 1 ? white : black;
-          }
-
-          for (; k < kEnd; k++) {
-            if (mask === 0) {
-              srcByte = src[srcPos++];
-              mask = 128;
-            }
-
-            dest32[destPos++] = srcByte & mask ? white : black;
-            mask >>= 1;
-          }
-        }
-
-        while (destPos < dest32DataLength) {
-          dest32[destPos++] = 0;
-        }
-
-        ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
-      }
-    } else if (imgData.kind === _util.ImageKind.RGBA_32BPP) {
-      j = 0;
-      elemsInThisChunk = width * FULL_CHUNK_HEIGHT * 4;
-
-      for (i = 0; i < fullChunks; i++) {
-        dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));
-        srcPos += elemsInThisChunk;
-        ctx.putImageData(chunkImgData, 0, j);
-        j += FULL_CHUNK_HEIGHT;
-      }
-
-      if (i < totalChunks) {
-        elemsInThisChunk = width * partialChunkHeight * 4;
-        dest.set(src.subarray(srcPos, srcPos + elemsInThisChunk));
-        ctx.putImageData(chunkImgData, 0, j);
-      }
-    } else if (imgData.kind === _util.ImageKind.RGB_24BPP) {
-      thisChunkHeight = FULL_CHUNK_HEIGHT;
-      elemsInThisChunk = width * thisChunkHeight;
-
-      for (i = 0; i < totalChunks; i++) {
-        if (i >= fullChunks) {
-          thisChunkHeight = partialChunkHeight;
-          elemsInThisChunk = width * thisChunkHeight;
-        }
-
-        destPos = 0;
-
-        for (j = elemsInThisChunk; j--;) {
-          dest[destPos++] = src[srcPos++];
-          dest[destPos++] = src[srcPos++];
-          dest[destPos++] = src[srcPos++];
-          dest[destPos++] = 255;
-        }
-
-        ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
-      }
-    } else {
-      throw new Error("bad image kind: ".concat(imgData.kind));
-    }
-  }
-
-  function putBinaryImageMask(ctx, imgData) {
-    var height = imgData.height,
-        width = imgData.width;
-    var partialChunkHeight = height % FULL_CHUNK_HEIGHT;
-    var fullChunks = (height - partialChunkHeight) / FULL_CHUNK_HEIGHT;
-    var totalChunks = partialChunkHeight === 0 ? fullChunks : fullChunks + 1;
-    var chunkImgData = ctx.createImageData(width, FULL_CHUNK_HEIGHT);
-    var srcPos = 0;
-    var src = imgData.data;
-    var dest = chunkImgData.data;
-
-    for (var i = 0; i < totalChunks; i++) {
-      var thisChunkHeight = i < fullChunks ? FULL_CHUNK_HEIGHT : partialChunkHeight;
-      var destPos = 3;
-
-      for (var j = 0; j < thisChunkHeight; j++) {
-        var mask = 0;
-
-        for (var k = 0; k < width; k++) {
-          if (!mask) {
-            var elem = src[srcPos++];
-            mask = 128;
-          }
-
-          dest[destPos] = elem & mask ? 0 : 255;
-          destPos += 4;
-          mask >>= 1;
-        }
-      }
-
-      ctx.putImageData(chunkImgData, 0, i * FULL_CHUNK_HEIGHT);
-    }
-  }
-
-  function copyCtxState(sourceCtx, destCtx) {
-    var properties = ['strokeStyle', 'fillStyle', 'fillRule', 'globalAlpha', 'lineWidth', 'lineCap', 'lineJoin', 'miterLimit', 'globalCompositeOperation', 'font'];
-
-    for (var i = 0, ii = properties.length; i < ii; i++) {
-      var property = properties[i];
-
-      if (sourceCtx[property] !== undefined) {
-        destCtx[property] = sourceCtx[property];
-      }
-    }
-
-    if (sourceCtx.setLineDash !== undefined) {
-      destCtx.setLineDash(sourceCtx.getLineDash());
-      destCtx.lineDashOffset = sourceCtx.lineDashOffset;
-    }
-  }
-
-  function resetCtxToDefault(ctx) {
-    ctx.strokeStyle = '#000000';
-    ctx.fillStyle = '#000000';
-    ctx.fillRule = 'nonzero';
-    ctx.globalAlpha = 1;
-    ctx.lineWidth = 1;
-    ctx.lineCap = 'butt';
-    ctx.lineJoin = 'miter';
-    ctx.miterLimit = 10;
-    ctx.globalCompositeOperation = 'source-over';
-    ctx.font = '10px sans-serif';
-
-    if (ctx.setLineDash !== undefined) {
-      ctx.setLineDash([]);
-      ctx.lineDashOffset = 0;
-    }
-  }
-
-  function composeSMaskBackdrop(bytes, r0, g0, b0) {
-    var length = bytes.length;
-
-    for (var i = 3; i < length; i += 4) {
-      var alpha = bytes[i];
-
-      if (alpha === 0) {
-        bytes[i - 3] = r0;
-        bytes[i - 2] = g0;
-        bytes[i - 1] = b0;
-      } else if (alpha < 255) {
-        var alpha_ = 255 - alpha;
-        bytes[i - 3] = bytes[i - 3] * alpha + r0 * alpha_ >> 8;
-        bytes[i - 2] = bytes[i - 2] * alpha + g0 * alpha_ >> 8;
-        bytes[i - 1] = bytes[i - 1] * alpha + b0 * alpha_ >> 8;
-      }
-    }
-  }
-
-  function composeSMaskAlpha(maskData, layerData, transferMap) {
-    var length = maskData.length;
-    var scale = 1 / 255;
-
-    for (var i = 3; i < length; i += 4) {
-      var alpha = transferMap ? transferMap[maskData[i]] : maskData[i];
-      layerData[i] = layerData[i] * alpha * scale | 0;
-    }
-  }
-
-  function composeSMaskLuminosity(maskData, layerData, transferMap) {
-    var length = maskData.length;
-
-    for (var i = 3; i < length; i += 4) {
-      var y = maskData[i - 3] * 77 + maskData[i - 2] * 152 + maskData[i - 1] * 28;
-      layerData[i] = transferMap ? layerData[i] * transferMap[y >> 8] >> 8 : layerData[i] * y >> 16;
-    }
-  }
-
-  function genericComposeSMask(maskCtx, layerCtx, width, height, subtype, backdrop, transferMap) {
-    var hasBackdrop = !!backdrop;
-    var r0 = hasBackdrop ? backdrop[0] : 0;
-    var g0 = hasBackdrop ? backdrop[1] : 0;
-    var b0 = hasBackdrop ? backdrop[2] : 0;
-    var composeFn;
-
-    if (subtype === 'Luminosity') {
-      composeFn = composeSMaskLuminosity;
-    } else {
-      composeFn = composeSMaskAlpha;
-    }
-
-    var PIXELS_TO_PROCESS = 1048576;
-    var chunkSize = Math.min(height, Math.ceil(PIXELS_TO_PROCESS / width));
-
-    for (var row = 0; row < height; row += chunkSize) {
-      var chunkHeight = Math.min(chunkSize, height - row);
-      var maskData = maskCtx.getImageData(0, row, width, chunkHeight);
-      var layerData = layerCtx.getImageData(0, row, width, chunkHeight);
-
-      if (hasBackdrop) {
-        composeSMaskBackdrop(maskData.data, r0, g0, b0);
-      }
-
-      composeFn(maskData.data, layerData.data, transferMap);
-      maskCtx.putImageData(layerData, 0, row);
-    }
-  }
-
-  function composeSMask(ctx, smask, layerCtx, webGLContext) {
-    var mask = smask.canvas;
-    var maskCtx = smask.context;
-    ctx.setTransform(smask.scaleX, 0, 0, smask.scaleY, smask.offsetX, smask.offsetY);
-    var backdrop = smask.backdrop || null;
-
-    if (!smask.transferMap && webGLContext.isEnabled) {
-      var composed = webGLContext.composeSMask({
-        layer: layerCtx.canvas,
-        mask: mask,
-        properties: {
-          subtype: smask.subtype,
-          backdrop: backdrop
-        }
-      });
-      ctx.setTransform(1, 0, 0, 1, 0, 0);
-      ctx.drawImage(composed, smask.offsetX, smask.offsetY);
-      return;
-    }
-
-    genericComposeSMask(maskCtx, layerCtx, mask.width, mask.height, smask.subtype, backdrop, smask.transferMap);
-    ctx.drawImage(mask, 0, 0);
-  }
-
-  var LINE_CAP_STYLES = ['butt', 'round', 'square'];
-  var LINE_JOIN_STYLES = ['miter', 'round', 'bevel'];
-  var NORMAL_CLIP = {};
-  var EO_CLIP = {};
-  CanvasGraphics.prototype = {
-    beginDrawing: function beginDrawing(_ref) {
-      var transform = _ref.transform,
-          viewport = _ref.viewport,
-          _ref$transparency = _ref.transparency,
-          transparency = _ref$transparency === void 0 ? false : _ref$transparency,
-          _ref$background = _ref.background,
-          background = _ref$background === void 0 ? null : _ref$background;
-      var width = this.ctx.canvas.width;
-      var height = this.ctx.canvas.height;
-      this.ctx.save();
-      this.ctx.fillStyle = background || 'rgb(255, 255, 255)';
-      this.ctx.fillRect(0, 0, width, height);
-      this.ctx.restore();
-
-      if (transparency) {
-        var transparentCanvas = this.cachedCanvases.getCanvas('transparent', width, height, true);
-        this.compositeCtx = this.ctx;
-        this.transparentCanvas = transparentCanvas.canvas;
-        this.ctx = transparentCanvas.context;
-        this.ctx.save();
-        this.ctx.transform.apply(this.ctx, this.compositeCtx.mozCurrentTransform);
-      }
-
-      this.ctx.save();
-      resetCtxToDefault(this.ctx);
-
-      if (transform) {
-        this.ctx.transform.apply(this.ctx, transform);
-      }
-
-      this.ctx.transform.apply(this.ctx, viewport.transform);
-      this.baseTransform = this.ctx.mozCurrentTransform.slice();
-
-      if (this.imageLayer) {
-        this.imageLayer.beginLayout();
-      }
-    },
-    executeOperatorList: function CanvasGraphics_executeOperatorList(operatorList, executionStartIdx, continueCallback, stepper) {
-      var argsArray = operatorList.argsArray;
-      var fnArray = operatorList.fnArray;
-      var i = executionStartIdx || 0;
-      var argsArrayLen = argsArray.length;
-
-      if (argsArrayLen === i) {
-        return i;
-      }
-
-      var chunkOperations = argsArrayLen - i > EXECUTION_STEPS && typeof continueCallback === 'function';
-      var endTime = chunkOperations ? Date.now() + EXECUTION_TIME : 0;
-      var steps = 0;
-      var commonObjs = this.commonObjs;
-      var objs = this.objs;
-      var fnId;
-
-      while (true) {
-        if (stepper !== undefined && i === stepper.nextBreakPoint) {
-          stepper.breakIt(i, continueCallback);
-          return i;
-        }
-
-        fnId = fnArray[i];
-
-        if (fnId !== _util.OPS.dependency) {
-          this[fnId].apply(this, argsArray[i]);
-        } else {
-          var _iteratorNormalCompletion = true;
-          var _didIteratorError = false;
-          var _iteratorError = undefined;
-
-          try {
-            for (var _iterator = argsArray[i][Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-              var depObjId = _step.value;
-              var objsPool = depObjId.startsWith('g_') ? commonObjs : objs;
-
-              if (!objsPool.has(depObjId)) {
-                objsPool.get(depObjId, continueCallback);
-                return i;
-              }
-            }
-          } catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-          } finally {
-            try {
-              if (!_iteratorNormalCompletion && _iterator["return"] != null) {
-                _iterator["return"]();
-              }
-            } finally {
-              if (_didIteratorError) {
-                throw _iteratorError;
-              }
-            }
-          }
-        }
-
-        i++;
-
-        if (i === argsArrayLen) {
-          return i;
-        }
-
-        if (chunkOperations && ++steps > EXECUTION_STEPS) {
-          if (Date.now() > endTime) {
-            continueCallback();
-            return i;
-          }
-
-          steps = 0;
-        }
-      }
-    },
-    endDrawing: function CanvasGraphics_endDrawing() {
-      if (this.current.activeSMask !== null) {
-        this.endSMaskGroup();
-      }
-
-      this.ctx.restore();
-
-      if (this.transparentCanvas) {
-        this.ctx = this.compositeCtx;
-        this.ctx.save();
-        this.ctx.setTransform(1, 0, 0, 1, 0, 0);
-        this.ctx.drawImage(this.transparentCanvas, 0, 0);
-        this.ctx.restore();
-        this.transparentCanvas = null;
-      }
-
-      this.cachedCanvases.clear();
-      this.webGLContext.clear();
-
-      if (this.imageLayer) {
-        this.imageLayer.endLayout();
-      }
-    },
-    setLineWidth: function CanvasGraphics_setLineWidth(width) {
-      this.current.lineWidth = width;
-      this.ctx.lineWidth = width;
-    },
-    setLineCap: function CanvasGraphics_setLineCap(style) {
-      this.ctx.lineCap = LINE_CAP_STYLES[style];
-    },
-    setLineJoin: function CanvasGraphics_setLineJoin(style) {
-      this.ctx.lineJoin = LINE_JOIN_STYLES[style];
-    },
-    setMiterLimit: function CanvasGraphics_setMiterLimit(limit) {
-      this.ctx.miterLimit = limit;
-    },
-    setDash: function CanvasGraphics_setDash(dashArray, dashPhase) {
-      var ctx = this.ctx;
-
-      if (ctx.setLineDash !== undefined) {
-        ctx.setLineDash(dashArray);
-        ctx.lineDashOffset = dashPhase;
-      }
-    },
-    setRenderingIntent: function setRenderingIntent(intent) {},
-    setFlatness: function setFlatness(flatness) {},
-    setGState: function CanvasGraphics_setGState(states) {
-      for (var i = 0, ii = states.length; i < ii; i++) {
-        var state = states[i];
-        var key = state[0];
-        var value = state[1];
-
-        switch (key) {
-          case 'LW':
-            this.setLineWidth(value);
-            break;
-
-          case 'LC':
-            this.setLineCap(value);
-            break;
-
-          case 'LJ':
-            this.setLineJoin(value);
-            break;
-
-          case 'ML':
-            this.setMiterLimit(value);
-            break;
-
-          case 'D':
-            this.setDash(value[0], value[1]);
-            break;
-
-          case 'RI':
-            this.setRenderingIntent(value);
-            break;
-
-          case 'FL':
-            this.setFlatness(value);
-            break;
-
-          case 'Font':
-            this.setFont(value[0], value[1]);
-            break;
-
-          case 'CA':
-            this.current.strokeAlpha = state[1];
-            break;
-
-          case 'ca':
-            this.current.fillAlpha = state[1];
-            this.ctx.globalAlpha = state[1];
-            break;
-
-          case 'BM':
-            this.ctx.globalCompositeOperation = value;
-            break;
-
-          case 'SMask':
-            if (this.current.activeSMask) {
-              if (this.stateStack.length > 0 && this.stateStack[this.stateStack.length - 1].activeSMask === this.current.activeSMask) {
-                this.suspendSMaskGroup();
-              } else {
-                this.endSMaskGroup();
-              }
-            }
-
-            this.current.activeSMask = value ? this.tempSMask : null;
-
-            if (this.current.activeSMask) {
-              this.beginSMaskGroup();
-            }
-
-            this.tempSMask = null;
-            break;
-        }
-      }
-    },
-    beginSMaskGroup: function CanvasGraphics_beginSMaskGroup() {
-      var activeSMask = this.current.activeSMask;
-      var drawnWidth = activeSMask.canvas.width;
-      var drawnHeight = activeSMask.canvas.height;
-      var cacheId = 'smaskGroupAt' + this.groupLevel;
-      var scratchCanvas = this.cachedCanvases.getCanvas(cacheId, drawnWidth, drawnHeight, true);
-      var currentCtx = this.ctx;
-      var currentTransform = currentCtx.mozCurrentTransform;
-      this.ctx.save();
-      var groupCtx = scratchCanvas.context;
-      groupCtx.scale(1 / activeSMask.scaleX, 1 / activeSMask.scaleY);
-      groupCtx.translate(-activeSMask.offsetX, -activeSMask.offsetY);
-      groupCtx.transform.apply(groupCtx, currentTransform);
-      activeSMask.startTransformInverse = groupCtx.mozCurrentTransformInverse;
-      copyCtxState(currentCtx, groupCtx);
-      this.ctx = groupCtx;
-      this.setGState([['BM', 'source-over'], ['ca', 1], ['CA', 1]]);
-      this.groupStack.push(currentCtx);
-      this.groupLevel++;
-    },
-    suspendSMaskGroup: function CanvasGraphics_endSMaskGroup() {
-      var groupCtx = this.ctx;
-      this.groupLevel--;
-      this.ctx = this.groupStack.pop();
-      composeSMask(this.ctx, this.current.activeSMask, groupCtx, this.webGLContext);
-      this.ctx.restore();
-      this.ctx.save();
-      copyCtxState(groupCtx, this.ctx);
-      this.current.resumeSMaskCtx = groupCtx;
-
-      var deltaTransform = _util.Util.transform(this.current.activeSMask.startTransformInverse, groupCtx.mozCurrentTransform);
-
-      this.ctx.transform.apply(this.ctx, deltaTransform);
-      groupCtx.save();
-      groupCtx.setTransform(1, 0, 0, 1, 0, 0);
-      groupCtx.clearRect(0, 0, groupCtx.canvas.width, groupCtx.canvas.height);
-      groupCtx.restore();
-    },
-    resumeSMaskGroup: function CanvasGraphics_endSMaskGroup() {
-      var groupCtx = this.current.resumeSMaskCtx;
-      var currentCtx = this.ctx;
-      this.ctx = groupCtx;
-      this.groupStack.push(currentCtx);
-      this.groupLevel++;
-    },
-    endSMaskGroup: function CanvasGraphics_endSMaskGroup() {
-      var groupCtx = this.ctx;
-      this.groupLevel--;
-      this.ctx = this.groupStack.pop();
-      composeSMask(this.ctx, this.current.activeSMask, groupCtx, this.webGLContext);
-      this.ctx.restore();
-      copyCtxState(groupCtx, this.ctx);
-
-      var deltaTransform = _util.Util.transform(this.current.activeSMask.startTransformInverse, groupCtx.mozCurrentTransform);
-
-      this.ctx.transform.apply(this.ctx, deltaTransform);
-    },
-    save: function CanvasGraphics_save() {
-      this.ctx.save();
-      var old = this.current;
-      this.stateStack.push(old);
-      this.current = old.clone();
-      this.current.resumeSMaskCtx = null;
-    },
-    restore: function CanvasGraphics_restore() {
-      if (this.current.resumeSMaskCtx) {
-        this.resumeSMaskGroup();
-      }
-
-      if (this.current.activeSMask !== null && (this.stateStack.length === 0 || this.stateStack[this.stateStack.length - 1].activeSMask !== this.current.activeSMask)) {
-        this.endSMaskGroup();
-      }
-
-      if (this.stateStack.length !== 0) {
-        this.current = this.stateStack.pop();
-        this.ctx.restore();
-        this.pendingClip = null;
-        this._cachedGetSinglePixelWidth = null;
-      }
-    },
-    transform: function CanvasGraphics_transform(a, b, c, d, e, f) {
-      this.ctx.transform(a, b, c, d, e, f);
-      this._cachedGetSinglePixelWidth = null;
-    },
-    constructPath: function CanvasGraphics_constructPath(ops, args) {
-      var ctx = this.ctx;
-      var current = this.current;
-      var x = current.x,
-          y = current.y;
-
-      for (var i = 0, j = 0, ii = ops.length; i < ii; i++) {
-        switch (ops[i] | 0) {
-          case _util.OPS.rectangle:
-            x = args[j++];
-            y = args[j++];
-            var width = args[j++];
-            var height = args[j++];
-
-            if (width === 0) {
-              width = this.getSinglePixelWidth();
-            }
-
-            if (height === 0) {
-              height = this.getSinglePixelWidth();
-            }
-
-            var xw = x + width;
-            var yh = y + height;
-            this.ctx.moveTo(x, y);
-            this.ctx.lineTo(xw, y);
-            this.ctx.lineTo(xw, yh);
-            this.ctx.lineTo(x, yh);
-            this.ctx.lineTo(x, y);
-            this.ctx.closePath();
-            break;
-
-          case _util.OPS.moveTo:
-            x = args[j++];
-            y = args[j++];
-            ctx.moveTo(x, y);
-            break;
-
-          case _util.OPS.lineTo:
-            x = args[j++];
-            y = args[j++];
-            ctx.lineTo(x, y);
-            break;
-
-          case _util.OPS.curveTo:
-            x = args[j + 4];
-            y = args[j + 5];
-            ctx.bezierCurveTo(args[j], args[j + 1], args[j + 2], args[j + 3], x, y);
-            j += 6;
-            break;
-
-          case _util.OPS.curveTo2:
-            ctx.bezierCurveTo(x, y, args[j], args[j + 1], args[j + 2], args[j + 3]);
-            x = args[j + 2];
-            y = args[j + 3];
-            j += 4;
-            break;
-
-          case _util.OPS.curveTo3:
-            x = args[j + 2];
-            y = args[j + 3];
-            ctx.bezierCurveTo(args[j], args[j + 1], x, y, x, y);
-            j += 4;
-            break;
-
-          case _util.OPS.closePath:
-            ctx.closePath();
-            break;
-        }
-      }
-
-      current.setCurrentPoint(x, y);
-    },
-    closePath: function CanvasGraphics_closePath() {
-      this.ctx.closePath();
-    },
-    stroke: function CanvasGraphics_stroke(consumePath) {
-      consumePath = typeof consumePath !== 'undefined' ? consumePath : true;
-      var ctx = this.ctx;
-      var strokeColor = this.current.strokeColor;
-      ctx.lineWidth = Math.max(this.getSinglePixelWidth() * MIN_WIDTH_FACTOR, this.current.lineWidth);
-      ctx.globalAlpha = this.current.strokeAlpha;
-
-      if (strokeColor && strokeColor.hasOwnProperty('type') && strokeColor.type === 'Pattern') {
-        ctx.save();
-        ctx.strokeStyle = strokeColor.getPattern(ctx, this);
-        ctx.stroke();
-        ctx.restore();
-      } else {
-        ctx.stroke();
-      }
-
-      if (consumePath) {
-        this.consumePath();
-      }
-
-      ctx.globalAlpha = this.current.fillAlpha;
-    },
-    closeStroke: function CanvasGraphics_closeStroke() {
-      this.closePath();
-      this.stroke();
-    },
-    fill: function CanvasGraphics_fill(consumePath) {
-      consumePath = typeof consumePath !== 'undefined' ? consumePath : true;
-      var ctx = this.ctx;
-      var fillColor = this.current.fillColor;
-      var isPatternFill = this.current.patternFill;
-      var needRestore = false;
-
-      if (isPatternFill) {
-        ctx.save();
-
-        if (this.baseTransform) {
-          ctx.setTransform.apply(ctx, this.baseTransform);
-        }
-
-        ctx.fillStyle = fillColor.getPattern(ctx, this);
-        needRestore = true;
-      }
-
-      if (this.pendingEOFill) {
-        ctx.fill('evenodd');
-        this.pendingEOFill = false;
-      } else {
-        ctx.fill();
-      }
-
-      if (needRestore) {
-        ctx.restore();
-      }
-
-      if (consumePath) {
-        this.consumePath();
-      }
-    },
-    eoFill: function CanvasGraphics_eoFill() {
-      this.pendingEOFill = true;
-      this.fill();
-    },
-    fillStroke: function CanvasGraphics_fillStroke() {
-      this.fill(false);
-      this.stroke(false);
-      this.consumePath();
-    },
-    eoFillStroke: function CanvasGraphics_eoFillStroke() {
-      this.pendingEOFill = true;
-      this.fillStroke();
-    },
-    closeFillStroke: function CanvasGraphics_closeFillStroke() {
-      this.closePath();
-      this.fillStroke();
-    },
-    closeEOFillStroke: function CanvasGraphics_closeEOFillStroke() {
-      this.pendingEOFill = true;
-      this.closePath();
-      this.fillStroke();
-    },
-    endPath: function CanvasGraphics_endPath() {
-      this.consumePath();
-    },
-    clip: function CanvasGraphics_clip() {
-      this.pendingClip = NORMAL_CLIP;
-    },
-    eoClip: function CanvasGraphics_eoClip() {
-      this.pendingClip = EO_CLIP;
-    },
-    beginText: function CanvasGraphics_beginText() {
-      this.current.textMatrix = _util.IDENTITY_MATRIX;
-      this.current.textMatrixScale = 1;
-      this.current.x = this.current.lineX = 0;
-      this.current.y = this.current.lineY = 0;
-    },
-    endText: function CanvasGraphics_endText() {
-      var paths = this.pendingTextPaths;
-      var ctx = this.ctx;
-
-      if (paths === undefined) {
-        ctx.beginPath();
-        return;
-      }
-
-      ctx.save();
-      ctx.beginPath();
-
-      for (var i = 0; i < paths.length; i++) {
-        var path = paths[i];
-        ctx.setTransform.apply(ctx, path.transform);
-        ctx.translate(path.x, path.y);
-        path.addToPath(ctx, path.fontSize);
-      }
-
-      ctx.restore();
-      ctx.clip();
-      ctx.beginPath();
-      delete this.pendingTextPaths;
-    },
-    setCharSpacing: function CanvasGraphics_setCharSpacing(spacing) {
-      this.current.charSpacing = spacing;
-    },
-    setWordSpacing: function CanvasGraphics_setWordSpacing(spacing) {
-      this.current.wordSpacing = spacing;
-    },
-    setHScale: function CanvasGraphics_setHScale(scale) {
-      this.current.textHScale = scale / 100;
-    },
-    setLeading: function CanvasGraphics_setLeading(leading) {
-      this.current.leading = -leading;
-    },
-    setFont: function CanvasGraphics_setFont(fontRefName, size) {
-      var fontObj = this.commonObjs.get(fontRefName);
-      var current = this.current;
-
-      if (!fontObj) {
-        throw new Error("Can't find font for ".concat(fontRefName));
-      }
-
-      current.fontMatrix = fontObj.fontMatrix ? fontObj.fontMatrix : _util.FONT_IDENTITY_MATRIX;
-
-      if (current.fontMatrix[0] === 0 || current.fontMatrix[3] === 0) {
-        (0, _util.warn)('Invalid font matrix for font ' + fontRefName);
-      }
-
-      if (size < 0) {
-        size = -size;
-        current.fontDirection = -1;
-      } else {
-        current.fontDirection = 1;
-      }
-
-      this.current.font = fontObj;
-      this.current.fontSize = size;
-
-      if (fontObj.isType3Font) {
-        return;
-      }
-
-      var name = fontObj.loadedName || 'sans-serif';
-      var bold = fontObj.black ? '900' : fontObj.bold ? 'bold' : 'normal';
-      var italic = fontObj.italic ? 'italic' : 'normal';
-      var typeface = "\"".concat(name, "\", ").concat(fontObj.fallbackName);
-      var browserFontSize = size < MIN_FONT_SIZE ? MIN_FONT_SIZE : size > MAX_FONT_SIZE ? MAX_FONT_SIZE : size;
-      this.current.fontSizeScale = size / browserFontSize;
-      this.ctx.font = "".concat(italic, " ").concat(bold, " ").concat(browserFontSize, "px ").concat(typeface);
-    },
-    setTextRenderingMode: function CanvasGraphics_setTextRenderingMode(mode) {
-      this.current.textRenderingMode = mode;
-    },
-    setTextRise: function CanvasGraphics_setTextRise(rise) {
-      this.current.textRise = rise;
-    },
-    moveText: function CanvasGraphics_moveText(x, y) {
-      this.current.x = this.current.lineX += x;
-      this.current.y = this.current.lineY += y;
-    },
-    setLeadingMoveText: function CanvasGraphics_setLeadingMoveText(x, y) {
-      this.setLeading(-y);
-      this.moveText(x, y);
-    },
-    setTextMatrix: function CanvasGraphics_setTextMatrix(a, b, c, d, e, f) {
-      this.current.textMatrix = [a, b, c, d, e, f];
-      this.current.textMatrixScale = Math.sqrt(a * a + b * b);
-      this.current.x = this.current.lineX = 0;
-      this.current.y = this.current.lineY = 0;
-    },
-    nextLine: function CanvasGraphics_nextLine() {
-      this.moveText(0, this.current.leading);
-    },
-    paintChar: function paintChar(character, x, y, patternTransform) {
-      var ctx = this.ctx;
-      var current = this.current;
-      var font = current.font;
-      var textRenderingMode = current.textRenderingMode;
-      var fontSize = current.fontSize / current.fontSizeScale;
-      var fillStrokeMode = textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK;
-      var isAddToPathSet = !!(textRenderingMode & _util.TextRenderingMode.ADD_TO_PATH_FLAG);
-      var patternFill = current.patternFill && font.data;
-      var addToPath;
-
-      if (font.disableFontFace || isAddToPathSet || patternFill) {
-        addToPath = font.getPathGenerator(this.commonObjs, character);
-      }
-
-      if (font.disableFontFace || patternFill) {
-        ctx.save();
-        ctx.translate(x, y);
-        ctx.beginPath();
-        addToPath(ctx, fontSize);
-
-        if (patternTransform) {
-          ctx.setTransform.apply(ctx, patternTransform);
-        }
-
-        if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
-          ctx.fill();
-        }
-
-        if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
-          ctx.stroke();
-        }
-
-        ctx.restore();
-      } else {
-        if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
-          ctx.fillText(character, x, y);
-        }
-
-        if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
-          ctx.strokeText(character, x, y);
-        }
-      }
-
-      if (isAddToPathSet) {
-        var paths = this.pendingTextPaths || (this.pendingTextPaths = []);
-        paths.push({
-          transform: ctx.mozCurrentTransform,
-          x: x,
-          y: y,
-          fontSize: fontSize,
-          addToPath: addToPath
-        });
-      }
-    },
-
-    get isFontSubpixelAAEnabled() {
-      var _this$cachedCanvases$ = this.cachedCanvases.getCanvas('isFontSubpixelAAEnabled', 10, 10),
-          ctx = _this$cachedCanvases$.context;
-
-      ctx.scale(1.5, 1);
-      ctx.fillText('I', 0, 10);
-      var data = ctx.getImageData(0, 0, 10, 10).data;
-      var enabled = false;
-
-      for (var i = 3; i < data.length; i += 4) {
-        if (data[i] > 0 && data[i] < 255) {
-          enabled = true;
-          break;
-        }
-      }
-
-      return (0, _util.shadow)(this, 'isFontSubpixelAAEnabled', enabled);
-    },
-
-    showText: function CanvasGraphics_showText(glyphs) {
-      var current = this.current;
-      var font = current.font;
-
-      if (font.isType3Font) {
-        return this.showType3Text(glyphs);
-      }
-
-      var fontSize = current.fontSize;
-
-      if (fontSize === 0) {
-        return undefined;
-      }
-
-      var ctx = this.ctx;
-      var fontSizeScale = current.fontSizeScale;
-      var charSpacing = current.charSpacing;
-      var wordSpacing = current.wordSpacing;
-      var fontDirection = current.fontDirection;
-      var textHScale = current.textHScale * fontDirection;
-      var glyphsLength = glyphs.length;
-      var vertical = font.vertical;
-      var spacingDir = vertical ? 1 : -1;
-      var defaultVMetrics = font.defaultVMetrics;
-      var widthAdvanceScale = fontSize * current.fontMatrix[0];
-      var simpleFillText = current.textRenderingMode === _util.TextRenderingMode.FILL && !font.disableFontFace && !current.patternFill;
-      ctx.save();
-      var patternTransform;
-
-      if (current.patternFill) {
-        ctx.save();
-        var pattern = current.fillColor.getPattern(ctx, this);
-        patternTransform = ctx.mozCurrentTransform;
-        ctx.restore();
-        ctx.fillStyle = pattern;
-      }
-
-      ctx.transform.apply(ctx, current.textMatrix);
-      ctx.translate(current.x, current.y + current.textRise);
-
-      if (fontDirection > 0) {
-        ctx.scale(textHScale, -1);
-      } else {
-        ctx.scale(textHScale, 1);
-      }
-
-      var lineWidth = current.lineWidth;
-      var scale = current.textMatrixScale;
-
-      if (scale === 0 || lineWidth === 0) {
-        var fillStrokeMode = current.textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK;
-
-        if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
-          this._cachedGetSinglePixelWidth = null;
-          lineWidth = this.getSinglePixelWidth() * MIN_WIDTH_FACTOR;
-        }
-      } else {
-        lineWidth /= scale;
-      }
-
-      if (fontSizeScale !== 1.0) {
-        ctx.scale(fontSizeScale, fontSizeScale);
-        lineWidth /= fontSizeScale;
-      }
-
-      ctx.lineWidth = lineWidth;
-      var x = 0,
-          i;
-
-      for (i = 0; i < glyphsLength; ++i) {
-        var glyph = glyphs[i];
-
-        if ((0, _util.isNum)(glyph)) {
-          x += spacingDir * glyph * fontSize / 1000;
-          continue;
-        }
-
-        var restoreNeeded = false;
-        var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
-        var character = glyph.fontChar;
-        var accent = glyph.accent;
-        var scaledX, scaledY, scaledAccentX, scaledAccentY;
-        var width = glyph.width;
-
-        if (vertical) {
-          var vmetric, vx, vy;
-          vmetric = glyph.vmetric || defaultVMetrics;
-          vx = glyph.vmetric ? vmetric[1] : width * 0.5;
-          vx = -vx * widthAdvanceScale;
-          vy = vmetric[2] * widthAdvanceScale;
-          width = vmetric ? -vmetric[0] : width;
-          scaledX = vx / fontSizeScale;
-          scaledY = (x + vy) / fontSizeScale;
-        } else {
-          scaledX = x / fontSizeScale;
-          scaledY = 0;
-        }
-
-        if (font.remeasure && width > 0) {
-          var measuredWidth = ctx.measureText(character).width * 1000 / fontSize * fontSizeScale;
-
-          if (width < measuredWidth && this.isFontSubpixelAAEnabled) {
-            var characterScaleX = width / measuredWidth;
-            restoreNeeded = true;
-            ctx.save();
-            ctx.scale(characterScaleX, 1);
-            scaledX /= characterScaleX;
-          } else if (width !== measuredWidth) {
-            scaledX += (width - measuredWidth) / 2000 * fontSize / fontSizeScale;
-          }
-        }
-
-        if (glyph.isInFont || font.missingFile) {
-          if (simpleFillText && !accent) {
-            ctx.fillText(character, scaledX, scaledY);
-          } else {
-            this.paintChar(character, scaledX, scaledY, patternTransform);
-
-            if (accent) {
-              scaledAccentX = scaledX + accent.offset.x / fontSizeScale;
-              scaledAccentY = scaledY - accent.offset.y / fontSizeScale;
-              this.paintChar(accent.fontChar, scaledAccentX, scaledAccentY, patternTransform);
-            }
-          }
-        }
-
-        var charWidth = width * widthAdvanceScale + spacing * fontDirection;
-        x += charWidth;
-
-        if (restoreNeeded) {
-          ctx.restore();
-        }
-      }
-
-      if (vertical) {
-        current.y -= x * textHScale;
-      } else {
-        current.x += x * textHScale;
-      }
-
-      ctx.restore();
-    },
-    showType3Text: function CanvasGraphics_showType3Text(glyphs) {
-      var ctx = this.ctx;
-      var current = this.current;
-      var font = current.font;
-      var fontSize = current.fontSize;
-      var fontDirection = current.fontDirection;
-      var spacingDir = font.vertical ? 1 : -1;
-      var charSpacing = current.charSpacing;
-      var wordSpacing = current.wordSpacing;
-      var textHScale = current.textHScale * fontDirection;
-      var fontMatrix = current.fontMatrix || _util.FONT_IDENTITY_MATRIX;
-      var glyphsLength = glyphs.length;
-      var isTextInvisible = current.textRenderingMode === _util.TextRenderingMode.INVISIBLE;
-      var i, glyph, width, spacingLength;
-
-      if (isTextInvisible || fontSize === 0) {
-        return;
-      }
-
-      this._cachedGetSinglePixelWidth = null;
-      ctx.save();
-      ctx.transform.apply(ctx, current.textMatrix);
-      ctx.translate(current.x, current.y);
-      ctx.scale(textHScale, fontDirection);
-
-      for (i = 0; i < glyphsLength; ++i) {
-        glyph = glyphs[i];
-
-        if ((0, _util.isNum)(glyph)) {
-          spacingLength = spacingDir * glyph * fontSize / 1000;
-          this.ctx.translate(spacingLength, 0);
-          current.x += spacingLength * textHScale;
-          continue;
-        }
-
-        var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
-        var operatorList = font.charProcOperatorList[glyph.operatorListId];
-
-        if (!operatorList) {
-          (0, _util.warn)("Type3 character \"".concat(glyph.operatorListId, "\" is not available."));
-          continue;
-        }
-
-        this.processingType3 = glyph;
-        this.save();
-        ctx.scale(fontSize, fontSize);
-        ctx.transform.apply(ctx, fontMatrix);
-        this.executeOperatorList(operatorList);
-        this.restore();
-
-        var transformed = _util.Util.applyTransform([glyph.width, 0], fontMatrix);
-
-        width = transformed[0] * fontSize + spacing;
-        ctx.translate(width, 0);
-        current.x += width * textHScale;
-      }
-
-      ctx.restore();
-      this.processingType3 = null;
-    },
-    setCharWidth: function CanvasGraphics_setCharWidth(xWidth, yWidth) {},
-    setCharWidthAndBounds: function CanvasGraphics_setCharWidthAndBounds(xWidth, yWidth, llx, lly, urx, ury) {
-      this.ctx.rect(llx, lly, urx - llx, ury - lly);
-      this.clip();
-      this.endPath();
-    },
-    getColorN_Pattern: function CanvasGraphics_getColorN_Pattern(IR) {
-      var _this = this;
-
-      var pattern;
-
-      if (IR[0] === 'TilingPattern') {
-        var color = IR[1];
-        var baseTransform = this.baseTransform || this.ctx.mozCurrentTransform.slice();
-        var canvasGraphicsFactory = {
-          createCanvasGraphics: function createCanvasGraphics(ctx) {
-            return new CanvasGraphics(ctx, _this.commonObjs, _this.objs, _this.canvasFactory, _this.webGLContext);
-          }
-        };
-        pattern = new _pattern_helper.TilingPattern(IR, color, this.ctx, canvasGraphicsFactory, baseTransform);
-      } else {
-        pattern = (0, _pattern_helper.getShadingPatternFromIR)(IR);
-      }
-
-      return pattern;
-    },
-    setStrokeColorN: function CanvasGraphics_setStrokeColorN() {
-      this.current.strokeColor = this.getColorN_Pattern(arguments);
-    },
-    setFillColorN: function CanvasGraphics_setFillColorN() {
-      this.current.fillColor = this.getColorN_Pattern(arguments);
-      this.current.patternFill = true;
-    },
-    setStrokeRGBColor: function CanvasGraphics_setStrokeRGBColor(r, g, b) {
-      var color = _util.Util.makeCssRgb(r, g, b);
-
-      this.ctx.strokeStyle = color;
-      this.current.strokeColor = color;
-    },
-    setFillRGBColor: function CanvasGraphics_setFillRGBColor(r, g, b) {
-      var color = _util.Util.makeCssRgb(r, g, b);
-
-      this.ctx.fillStyle = color;
-      this.current.fillColor = color;
-      this.current.patternFill = false;
-    },
-    shadingFill: function CanvasGraphics_shadingFill(patternIR) {
-      var ctx = this.ctx;
-      this.save();
-      var pattern = (0, _pattern_helper.getShadingPatternFromIR)(patternIR);
-      ctx.fillStyle = pattern.getPattern(ctx, this, true);
-      var inv = ctx.mozCurrentTransformInverse;
-
-      if (inv) {
-        var canvas = ctx.canvas;
-        var width = canvas.width;
-        var height = canvas.height;
-
-        var bl = _util.Util.applyTransform([0, 0], inv);
-
-        var br = _util.Util.applyTransform([0, height], inv);
-
-        var ul = _util.Util.applyTransform([width, 0], inv);
-
-        var ur = _util.Util.applyTransform([width, height], inv);
-
-        var x0 = Math.min(bl[0], br[0], ul[0], ur[0]);
-        var y0 = Math.min(bl[1], br[1], ul[1], ur[1]);
-        var x1 = Math.max(bl[0], br[0], ul[0], ur[0]);
-        var y1 = Math.max(bl[1], br[1], ul[1], ur[1]);
-        this.ctx.fillRect(x0, y0, x1 - x0, y1 - y0);
-      } else {
-        this.ctx.fillRect(-1e10, -1e10, 2e10, 2e10);
-      }
-
-      this.restore();
-    },
-    beginInlineImage: function CanvasGraphics_beginInlineImage() {
-      (0, _util.unreachable)('Should not call beginInlineImage');
-    },
-    beginImageData: function CanvasGraphics_beginImageData() {
-      (0, _util.unreachable)('Should not call beginImageData');
-    },
-    paintFormXObjectBegin: function CanvasGraphics_paintFormXObjectBegin(matrix, bbox) {
-      this.save();
-      this.baseTransformStack.push(this.baseTransform);
-
-      if (Array.isArray(matrix) && matrix.length === 6) {
-        this.transform.apply(this, matrix);
-      }
-
-      this.baseTransform = this.ctx.mozCurrentTransform;
-
-      if (bbox) {
-        var width = bbox[2] - bbox[0];
-        var height = bbox[3] - bbox[1];
-        this.ctx.rect(bbox[0], bbox[1], width, height);
-        this.clip();
-        this.endPath();
-      }
-    },
-    paintFormXObjectEnd: function CanvasGraphics_paintFormXObjectEnd() {
-      this.restore();
-      this.baseTransform = this.baseTransformStack.pop();
-    },
-    beginGroup: function CanvasGraphics_beginGroup(group) {
-      this.save();
-      var currentCtx = this.ctx;
-
-      if (!group.isolated) {
-        (0, _util.info)('TODO: Support non-isolated groups.');
-      }
-
-      if (group.knockout) {
-        (0, _util.warn)('Knockout groups not supported.');
-      }
-
-      var currentTransform = currentCtx.mozCurrentTransform;
-
-      if (group.matrix) {
-        currentCtx.transform.apply(currentCtx, group.matrix);
-      }
-
-      if (!group.bbox) {
-        throw new Error('Bounding box is required.');
-      }
-
-      var bounds = _util.Util.getAxialAlignedBoundingBox(group.bbox, currentCtx.mozCurrentTransform);
-
-      var canvasBounds = [0, 0, currentCtx.canvas.width, currentCtx.canvas.height];
-      bounds = _util.Util.intersect(bounds, canvasBounds) || [0, 0, 0, 0];
-      var offsetX = Math.floor(bounds[0]);
-      var offsetY = Math.floor(bounds[1]);
-      var drawnWidth = Math.max(Math.ceil(bounds[2]) - offsetX, 1);
-      var drawnHeight = Math.max(Math.ceil(bounds[3]) - offsetY, 1);
-      var scaleX = 1,
-          scaleY = 1;
-
-      if (drawnWidth > MAX_GROUP_SIZE) {
-        scaleX = drawnWidth / MAX_GROUP_SIZE;
-        drawnWidth = MAX_GROUP_SIZE;
-      }
-
-      if (drawnHeight > MAX_GROUP_SIZE) {
-        scaleY = drawnHeight / MAX_GROUP_SIZE;
-        drawnHeight = MAX_GROUP_SIZE;
-      }
-
-      var cacheId = 'groupAt' + this.groupLevel;
-
-      if (group.smask) {
-        cacheId += '_smask_' + this.smaskCounter++ % 2;
-      }
-
-      var scratchCanvas = this.cachedCanvases.getCanvas(cacheId, drawnWidth, drawnHeight, true);
-      var groupCtx = scratchCanvas.context;
-      groupCtx.scale(1 / scaleX, 1 / scaleY);
-      groupCtx.translate(-offsetX, -offsetY);
-      groupCtx.transform.apply(groupCtx, currentTransform);
-
-      if (group.smask) {
-        this.smaskStack.push({
-          canvas: scratchCanvas.canvas,
-          context: groupCtx,
-          offsetX: offsetX,
-          offsetY: offsetY,
-          scaleX: scaleX,
-          scaleY: scaleY,
-          subtype: group.smask.subtype,
-          backdrop: group.smask.backdrop,
-          transferMap: group.smask.transferMap || null,
-          startTransformInverse: null
-        });
-      } else {
-        currentCtx.setTransform(1, 0, 0, 1, 0, 0);
-        currentCtx.translate(offsetX, offsetY);
-        currentCtx.scale(scaleX, scaleY);
-      }
-
-      copyCtxState(currentCtx, groupCtx);
-      this.ctx = groupCtx;
-      this.setGState([['BM', 'source-over'], ['ca', 1], ['CA', 1]]);
-      this.groupStack.push(currentCtx);
-      this.groupLevel++;
-      this.current.activeSMask = null;
-    },
-    endGroup: function CanvasGraphics_endGroup(group) {
-      this.groupLevel--;
-      var groupCtx = this.ctx;
-      this.ctx = this.groupStack.pop();
-
-      if (this.ctx.imageSmoothingEnabled !== undefined) {
-        this.ctx.imageSmoothingEnabled = false;
-      } else {
-        this.ctx.mozImageSmoothingEnabled = false;
-      }
-
-      if (group.smask) {
-        this.tempSMask = this.smaskStack.pop();
-      } else {
-        this.ctx.drawImage(groupCtx.canvas, 0, 0);
-      }
-
-      this.restore();
-    },
-    beginAnnotations: function CanvasGraphics_beginAnnotations() {
-      this.save();
-
-      if (this.baseTransform) {
-        this.ctx.setTransform.apply(this.ctx, this.baseTransform);
-      }
-    },
-    endAnnotations: function CanvasGraphics_endAnnotations() {
-      this.restore();
-    },
-    beginAnnotation: function CanvasGraphics_beginAnnotation(rect, transform, matrix) {
-      this.save();
-      resetCtxToDefault(this.ctx);
-      this.current = new CanvasExtraState();
-
-      if (Array.isArray(rect) && rect.length === 4) {
-        var width = rect[2] - rect[0];
-        var height = rect[3] - rect[1];
-        this.ctx.rect(rect[0], rect[1], width, height);
-        this.clip();
-        this.endPath();
-      }
-
-      this.transform.apply(this, transform);
-      this.transform.apply(this, matrix);
-    },
-    endAnnotation: function CanvasGraphics_endAnnotation() {
-      this.restore();
-    },
-    paintJpegXObject: function CanvasGraphics_paintJpegXObject(objId, w, h) {
-      var domImage = this.processingType3 ? this.commonObjs.get(objId) : this.objs.get(objId);
-
-      if (!domImage) {
-        (0, _util.warn)('Dependent image isn\'t ready yet');
-        return;
-      }
-
-      this.save();
-      var ctx = this.ctx;
-      ctx.scale(1 / w, -1 / h);
-      ctx.drawImage(domImage, 0, 0, domImage.width, domImage.height, 0, -h, w, h);
-
-      if (this.imageLayer) {
-        var currentTransform = ctx.mozCurrentTransformInverse;
-        var position = this.getCanvasPosition(0, 0);
-        this.imageLayer.appendImage({
-          objId: objId,
-          left: position[0],
-          top: position[1],
-          width: w / currentTransform[0],
-          height: h / currentTransform[3]
-        });
-      }
-
-      this.restore();
-    },
-    paintImageMaskXObject: function CanvasGraphics_paintImageMaskXObject(img) {
-      var ctx = this.ctx;
-      var width = img.width,
-          height = img.height;
-      var fillColor = this.current.fillColor;
-      var isPatternFill = this.current.patternFill;
-      var glyph = this.processingType3;
-
-      if (COMPILE_TYPE3_GLYPHS && glyph && glyph.compiled === undefined) {
-        if (width <= MAX_SIZE_TO_COMPILE && height <= MAX_SIZE_TO_COMPILE) {
-          glyph.compiled = compileType3Glyph({
-            data: img.data,
-            width: width,
-            height: height
-          });
-        } else {
-          glyph.compiled = null;
-        }
-      }
-
-      if (glyph && glyph.compiled) {
-        glyph.compiled(ctx);
-        return;
-      }
-
-      var maskCanvas = this.cachedCanvases.getCanvas('maskCanvas', width, height);
-      var maskCtx = maskCanvas.context;
-      maskCtx.save();
-      putBinaryImageMask(maskCtx, img);
-      maskCtx.globalCompositeOperation = 'source-in';
-      maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this) : fillColor;
-      maskCtx.fillRect(0, 0, width, height);
-      maskCtx.restore();
-      this.paintInlineImageXObject(maskCanvas.canvas);
-    },
-    paintImageMaskXObjectRepeat: function CanvasGraphics_paintImageMaskXObjectRepeat(imgData, scaleX, scaleY, positions) {
-      var width = imgData.width;
-      var height = imgData.height;
-      var fillColor = this.current.fillColor;
-      var isPatternFill = this.current.patternFill;
-      var maskCanvas = this.cachedCanvases.getCanvas('maskCanvas', width, height);
-      var maskCtx = maskCanvas.context;
-      maskCtx.save();
-      putBinaryImageMask(maskCtx, imgData);
-      maskCtx.globalCompositeOperation = 'source-in';
-      maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this) : fillColor;
-      maskCtx.fillRect(0, 0, width, height);
-      maskCtx.restore();
-      var ctx = this.ctx;
-
-      for (var i = 0, ii = positions.length; i < ii; i += 2) {
-        ctx.save();
-        ctx.transform(scaleX, 0, 0, scaleY, positions[i], positions[i + 1]);
-        ctx.scale(1, -1);
-        ctx.drawImage(maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);
-        ctx.restore();
-      }
-    },
-    paintImageMaskXObjectGroup: function CanvasGraphics_paintImageMaskXObjectGroup(images) {
-      var ctx = this.ctx;
-      var fillColor = this.current.fillColor;
-      var isPatternFill = this.current.patternFill;
-
-      for (var i = 0, ii = images.length; i < ii; i++) {
-        var image = images[i];
-        var width = image.width,
-            height = image.height;
-        var maskCanvas = this.cachedCanvases.getCanvas('maskCanvas', width, height);
-        var maskCtx = maskCanvas.context;
-        maskCtx.save();
-        putBinaryImageMask(maskCtx, image);
-        maskCtx.globalCompositeOperation = 'source-in';
-        maskCtx.fillStyle = isPatternFill ? fillColor.getPattern(maskCtx, this) : fillColor;
-        maskCtx.fillRect(0, 0, width, height);
-        maskCtx.restore();
-        ctx.save();
-        ctx.transform.apply(ctx, image.transform);
-        ctx.scale(1, -1);
-        ctx.drawImage(maskCanvas.canvas, 0, 0, width, height, 0, -1, 1, 1);
-        ctx.restore();
-      }
-    },
-    paintImageXObject: function CanvasGraphics_paintImageXObject(objId) {
-      var imgData = this.processingType3 ? this.commonObjs.get(objId) : this.objs.get(objId);
-
-      if (!imgData) {
-        (0, _util.warn)('Dependent image isn\'t ready yet');
-        return;
-      }
-
-      this.paintInlineImageXObject(imgData);
-    },
-    paintImageXObjectRepeat: function CanvasGraphics_paintImageXObjectRepeat(objId, scaleX, scaleY, positions) {
-      var imgData = this.processingType3 ? this.commonObjs.get(objId) : this.objs.get(objId);
-
-      if (!imgData) {
-        (0, _util.warn)('Dependent image isn\'t ready yet');
-        return;
-      }
-
-      var width = imgData.width;
-      var height = imgData.height;
-      var map = [];
-
-      for (var i = 0, ii = positions.length; i < ii; i += 2) {
-        map.push({
-          transform: [scaleX, 0, 0, scaleY, positions[i], positions[i + 1]],
-          x: 0,
-          y: 0,
-          w: width,
-          h: height
-        });
-      }
-
-      this.paintInlineImageXObjectGroup(imgData, map);
-    },
-    paintInlineImageXObject: function CanvasGraphics_paintInlineImageXObject(imgData) {
-      var width = imgData.width;
-      var height = imgData.height;
-      var ctx = this.ctx;
-      this.save();
-      ctx.scale(1 / width, -1 / height);
-      var currentTransform = ctx.mozCurrentTransformInverse;
-      var a = currentTransform[0],
-          b = currentTransform[1];
-      var widthScale = Math.max(Math.sqrt(a * a + b * b), 1);
-      var c = currentTransform[2],
-          d = currentTransform[3];
-      var heightScale = Math.max(Math.sqrt(c * c + d * d), 1);
-      var imgToPaint, tmpCanvas;
-
-      if (typeof HTMLElement === 'function' && imgData instanceof HTMLElement || !imgData.data) {
-        imgToPaint = imgData;
-      } else {
-        tmpCanvas = this.cachedCanvases.getCanvas('inlineImage', width, height);
-        var tmpCtx = tmpCanvas.context;
-        putBinaryImageData(tmpCtx, imgData);
-        imgToPaint = tmpCanvas.canvas;
-      }
-
-      var paintWidth = width,
-          paintHeight = height;
-      var tmpCanvasId = 'prescale1';
-
-      while (widthScale > 2 && paintWidth > 1 || heightScale > 2 && paintHeight > 1) {
-        var newWidth = paintWidth,
-            newHeight = paintHeight;
-
-        if (widthScale > 2 && paintWidth > 1) {
-          newWidth = Math.ceil(paintWidth / 2);
-          widthScale /= paintWidth / newWidth;
-        }
-
-        if (heightScale > 2 && paintHeight > 1) {
-          newHeight = Math.ceil(paintHeight / 2);
-          heightScale /= paintHeight / newHeight;
-        }
-
-        tmpCanvas = this.cachedCanvases.getCanvas(tmpCanvasId, newWidth, newHeight);
-        tmpCtx = tmpCanvas.context;
-        tmpCtx.clearRect(0, 0, newWidth, newHeight);
-        tmpCtx.drawImage(imgToPaint, 0, 0, paintWidth, paintHeight, 0, 0, newWidth, newHeight);
-        imgToPaint = tmpCanvas.canvas;
-        paintWidth = newWidth;
-        paintHeight = newHeight;
-        tmpCanvasId = tmpCanvasId === 'prescale1' ? 'prescale2' : 'prescale1';
-      }
-
-      ctx.drawImage(imgToPaint, 0, 0, paintWidth, paintHeight, 0, -height, width, height);
-
-      if (this.imageLayer) {
-        var position = this.getCanvasPosition(0, -height);
-        this.imageLayer.appendImage({
-          imgData: imgData,
-          left: position[0],
-          top: position[1],
-          width: width / currentTransform[0],
-          height: height / currentTransform[3]
-        });
-      }
-
-      this.restore();
-    },
-    paintInlineImageXObjectGroup: function CanvasGraphics_paintInlineImageXObjectGroup(imgData, map) {
-      var ctx = this.ctx;
-      var w = imgData.width;
-      var h = imgData.height;
-      var tmpCanvas = this.cachedCanvases.getCanvas('inlineImage', w, h);
-      var tmpCtx = tmpCanvas.context;
-      putBinaryImageData(tmpCtx, imgData);
-
-      for (var i = 0, ii = map.length; i < ii; i++) {
-        var entry = map[i];
-        ctx.save();
-        ctx.transform.apply(ctx, entry.transform);
-        ctx.scale(1, -1);
-        ctx.drawImage(tmpCanvas.canvas, entry.x, entry.y, entry.w, entry.h, 0, -1, 1, 1);
-
-        if (this.imageLayer) {
-          var position = this.getCanvasPosition(entry.x, entry.y);
-          this.imageLayer.appendImage({
-            imgData: imgData,
-            left: position[0],
-            top: position[1],
-            width: w,
-            height: h
-          });
-        }
-
-        ctx.restore();
-      }
-    },
-    paintSolidColorImageMask: function CanvasGraphics_paintSolidColorImageMask() {
-      this.ctx.fillRect(0, 0, 1, 1);
-    },
-    paintXObject: function CanvasGraphics_paintXObject() {
-      (0, _util.warn)('Unsupported \'paintXObject\' command.');
-    },
-    markPoint: function CanvasGraphics_markPoint(tag) {},
-    markPointProps: function CanvasGraphics_markPointProps(tag, properties) {},
-    beginMarkedContent: function CanvasGraphics_beginMarkedContent(tag) {},
-    beginMarkedContentProps: function CanvasGraphics_beginMarkedContentProps(tag, properties) {},
-    endMarkedContent: function CanvasGraphics_endMarkedContent() {},
-    beginCompat: function CanvasGraphics_beginCompat() {},
-    endCompat: function CanvasGraphics_endCompat() {},
-    consumePath: function CanvasGraphics_consumePath() {
-      var ctx = this.ctx;
-
-      if (this.pendingClip) {
-        if (this.pendingClip === EO_CLIP) {
-          ctx.clip('evenodd');
-        } else {
-          ctx.clip();
-        }
-
-        this.pendingClip = null;
-      }
-
-      ctx.beginPath();
-    },
-    getSinglePixelWidth: function getSinglePixelWidth(scale) {
-      if (this._cachedGetSinglePixelWidth === null) {
-        var inverse = this.ctx.mozCurrentTransformInverse;
-        this._cachedGetSinglePixelWidth = Math.sqrt(Math.max(inverse[0] * inverse[0] + inverse[1] * inverse[1], inverse[2] * inverse[2] + inverse[3] * inverse[3]));
-      }
-
-      return this._cachedGetSinglePixelWidth;
-    },
-    getCanvasPosition: function CanvasGraphics_getCanvasPosition(x, y) {
-      var transform = this.ctx.mozCurrentTransform;
-      return [transform[0] * x + transform[2] * y + transform[4], transform[1] * x + transform[3] * y + transform[5]];
-    }
-  };
-
-  for (var op in _util.OPS) {
-    CanvasGraphics.prototype[_util.OPS[op]] = CanvasGraphics.prototype[op];
-  }
-
-  return CanvasGraphics;
-}();
-
-exports.CanvasGraphics = CanvasGraphics;
-
-/***/ }),
-/* 155 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getShadingPatternFromIR = getShadingPatternFromIR;
-exports.TilingPattern = void 0;
-
-var _util = __w_pdfjs_require__(1);
-
-var ShadingIRs = {};
-ShadingIRs.RadialAxial = {
-  fromIR: function RadialAxial_fromIR(raw) {
-    var type = raw[1];
-    var colorStops = raw[2];
-    var p0 = raw[3];
-    var p1 = raw[4];
-    var r0 = raw[5];
-    var r1 = raw[6];
-    return {
-      type: 'Pattern',
-      getPattern: function RadialAxial_getPattern(ctx) {
-        var grad;
-
-        if (type === 'axial') {
-          grad = ctx.createLinearGradient(p0[0], p0[1], p1[0], p1[1]);
-        } else if (type === 'radial') {
-          grad = ctx.createRadialGradient(p0[0], p0[1], r0, p1[0], p1[1], r1);
-        }
-
-        for (var i = 0, ii = colorStops.length; i < ii; ++i) {
-          var c = colorStops[i];
-          grad.addColorStop(c[0], c[1]);
-        }
-
-        return grad;
-      }
-    };
-  }
-};
-
-var createMeshCanvas = function createMeshCanvasClosure() {
-  function drawTriangle(data, context, p1, p2, p3, c1, c2, c3) {
-    var coords = context.coords,
-        colors = context.colors;
-    var bytes = data.data,
-        rowSize = data.width * 4;
-    var tmp;
-
-    if (coords[p1 + 1] > coords[p2 + 1]) {
-      tmp = p1;
-      p1 = p2;
-      p2 = tmp;
-      tmp = c1;
-      c1 = c2;
-      c2 = tmp;
-    }
-
-    if (coords[p2 + 1] > coords[p3 + 1]) {
-      tmp = p2;
-      p2 = p3;
-      p3 = tmp;
-      tmp = c2;
-      c2 = c3;
-      c3 = tmp;
-    }
-
-    if (coords[p1 + 1] > coords[p2 + 1]) {
-      tmp = p1;
-      p1 = p2;
-      p2 = tmp;
-      tmp = c1;
-      c1 = c2;
-      c2 = tmp;
-    }
-
-    var x1 = (coords[p1] + context.offsetX) * context.scaleX;
-    var y1 = (coords[p1 + 1] + context.offsetY) * context.scaleY;
-    var x2 = (coords[p2] + context.offsetX) * context.scaleX;
-    var y2 = (coords[p2 + 1] + context.offsetY) * context.scaleY;
-    var x3 = (coords[p3] + context.offsetX) * context.scaleX;
-    var y3 = (coords[p3 + 1] + context.offsetY) * context.scaleY;
-
-    if (y1 >= y3) {
-      return;
-    }
-
-    var c1r = colors[c1],
-        c1g = colors[c1 + 1],
-        c1b = colors[c1 + 2];
-    var c2r = colors[c2],
-        c2g = colors[c2 + 1],
-        c2b = colors[c2 + 2];
-    var c3r = colors[c3],
-        c3g = colors[c3 + 1],
-        c3b = colors[c3 + 2];
-    var minY = Math.round(y1),
-        maxY = Math.round(y3);
-    var xa, car, cag, cab;
-    var xb, cbr, cbg, cbb;
-    var k;
-
-    for (var y = minY; y <= maxY; y++) {
-      if (y < y2) {
-        k = y < y1 ? 0 : y1 === y2 ? 1 : (y1 - y) / (y1 - y2);
-        xa = x1 - (x1 - x2) * k;
-        car = c1r - (c1r - c2r) * k;
-        cag = c1g - (c1g - c2g) * k;
-        cab = c1b - (c1b - c2b) * k;
-      } else {
-        k = y > y3 ? 1 : y2 === y3 ? 0 : (y2 - y) / (y2 - y3);
-        xa = x2 - (x2 - x3) * k;
-        car = c2r - (c2r - c3r) * k;
-        cag = c2g - (c2g - c3g) * k;
-        cab = c2b - (c2b - c3b) * k;
-      }
-
-      k = y < y1 ? 0 : y > y3 ? 1 : (y1 - y) / (y1 - y3);
-      xb = x1 - (x1 - x3) * k;
-      cbr = c1r - (c1r - c3r) * k;
-      cbg = c1g - (c1g - c3g) * k;
-      cbb = c1b - (c1b - c3b) * k;
-      var x1_ = Math.round(Math.min(xa, xb));
-      var x2_ = Math.round(Math.max(xa, xb));
-      var j = rowSize * y + x1_ * 4;
-
-      for (var x = x1_; x <= x2_; x++) {
-        k = (xa - x) / (xa - xb);
-        k = k < 0 ? 0 : k > 1 ? 1 : k;
-        bytes[j++] = car - (car - cbr) * k | 0;
-        bytes[j++] = cag - (cag - cbg) * k | 0;
-        bytes[j++] = cab - (cab - cbb) * k | 0;
-        bytes[j++] = 255;
-      }
-    }
-  }
-
-  function drawFigure(data, figure, context) {
-    var ps = figure.coords;
-    var cs = figure.colors;
-    var i, ii;
-
-    switch (figure.type) {
-      case 'lattice':
-        var verticesPerRow = figure.verticesPerRow;
-        var rows = Math.floor(ps.length / verticesPerRow) - 1;
-        var cols = verticesPerRow - 1;
-
-        for (i = 0; i < rows; i++) {
-          var q = i * verticesPerRow;
-
-          for (var j = 0; j < cols; j++, q++) {
-            drawTriangle(data, context, ps[q], ps[q + 1], ps[q + verticesPerRow], cs[q], cs[q + 1], cs[q + verticesPerRow]);
-            drawTriangle(data, context, ps[q + verticesPerRow + 1], ps[q + 1], ps[q + verticesPerRow], cs[q + verticesPerRow + 1], cs[q + 1], cs[q + verticesPerRow]);
-          }
-        }
-
-        break;
-
-      case 'triangles':
-        for (i = 0, ii = ps.length; i < ii; i += 3) {
-          drawTriangle(data, context, ps[i], ps[i + 1], ps[i + 2], cs[i], cs[i + 1], cs[i + 2]);
-        }
-
-        break;
-
-      default:
-        throw new Error('illegal figure');
-    }
-  }
-
-  function createMeshCanvas(bounds, combinesScale, coords, colors, figures, backgroundColor, cachedCanvases, webGLContext) {
-    var EXPECTED_SCALE = 1.1;
-    var MAX_PATTERN_SIZE = 3000;
-    var BORDER_SIZE = 2;
-    var offsetX = Math.floor(bounds[0]);
-    var offsetY = Math.floor(bounds[1]);
-    var boundsWidth = Math.ceil(bounds[2]) - offsetX;
-    var boundsHeight = Math.ceil(bounds[3]) - offsetY;
-    var width = Math.min(Math.ceil(Math.abs(boundsWidth * combinesScale[0] * EXPECTED_SCALE)), MAX_PATTERN_SIZE);
-    var height = Math.min(Math.ceil(Math.abs(boundsHeight * combinesScale[1] * EXPECTED_SCALE)), MAX_PATTERN_SIZE);
-    var scaleX = boundsWidth / width;
-    var scaleY = boundsHeight / height;
-    var context = {
-      coords: coords,
-      colors: colors,
-      offsetX: -offsetX,
-      offsetY: -offsetY,
-      scaleX: 1 / scaleX,
-      scaleY: 1 / scaleY
-    };
-    var paddedWidth = width + BORDER_SIZE * 2;
-    var paddedHeight = height + BORDER_SIZE * 2;
-    var canvas, tmpCanvas, i, ii;
-
-    if (webGLContext.isEnabled) {
-      canvas = webGLContext.drawFigures({
-        width: width,
-        height: height,
-        backgroundColor: backgroundColor,
-        figures: figures,
-        context: context
-      });
-      tmpCanvas = cachedCanvases.getCanvas('mesh', paddedWidth, paddedHeight, false);
-      tmpCanvas.context.drawImage(canvas, BORDER_SIZE, BORDER_SIZE);
-      canvas = tmpCanvas.canvas;
-    } else {
-      tmpCanvas = cachedCanvases.getCanvas('mesh', paddedWidth, paddedHeight, false);
-      var tmpCtx = tmpCanvas.context;
-      var data = tmpCtx.createImageData(width, height);
-
-      if (backgroundColor) {
-        var bytes = data.data;
-
-        for (i = 0, ii = bytes.length; i < ii; i += 4) {
-          bytes[i] = backgroundColor[0];
-          bytes[i + 1] = backgroundColor[1];
-          bytes[i + 2] = backgroundColor[2];
-          bytes[i + 3] = 255;
-        }
-      }
-
-      for (i = 0; i < figures.length; i++) {
-        drawFigure(data, figures[i], context);
-      }
-
-      tmpCtx.putImageData(data, BORDER_SIZE, BORDER_SIZE);
-      canvas = tmpCanvas.canvas;
-    }
-
-    return {
-      canvas: canvas,
-      offsetX: offsetX - BORDER_SIZE * scaleX,
-      offsetY: offsetY - BORDER_SIZE * scaleY,
-      scaleX: scaleX,
-      scaleY: scaleY
-    };
-  }
-
-  return createMeshCanvas;
-}();
-
-ShadingIRs.Mesh = {
-  fromIR: function Mesh_fromIR(raw) {
-    var coords = raw[2];
-    var colors = raw[3];
-    var figures = raw[4];
-    var bounds = raw[5];
-    var matrix = raw[6];
-    var background = raw[8];
-    return {
-      type: 'Pattern',
-      getPattern: function Mesh_getPattern(ctx, owner, shadingFill) {
-        var scale;
-
-        if (shadingFill) {
-          scale = _util.Util.singularValueDecompose2dScale(ctx.mozCurrentTransform);
-        } else {
-          scale = _util.Util.singularValueDecompose2dScale(owner.baseTransform);
-
-          if (matrix) {
-            var matrixScale = _util.Util.singularValueDecompose2dScale(matrix);
-
-            scale = [scale[0] * matrixScale[0], scale[1] * matrixScale[1]];
-          }
-        }
-
-        var temporaryPatternCanvas = createMeshCanvas(bounds, scale, coords, colors, figures, shadingFill ? null : background, owner.cachedCanvases, owner.webGLContext);
-
-        if (!shadingFill) {
-          ctx.setTransform.apply(ctx, owner.baseTransform);
-
-          if (matrix) {
-            ctx.transform.apply(ctx, matrix);
-          }
-        }
-
-        ctx.translate(temporaryPatternCanvas.offsetX, temporaryPatternCanvas.offsetY);
-        ctx.scale(temporaryPatternCanvas.scaleX, temporaryPatternCanvas.scaleY);
-        return ctx.createPattern(temporaryPatternCanvas.canvas, 'no-repeat');
-      }
-    };
-  }
-};
-ShadingIRs.Dummy = {
-  fromIR: function Dummy_fromIR() {
-    return {
-      type: 'Pattern',
-      getPattern: function Dummy_fromIR_getPattern() {
-        return 'hotpink';
-      }
-    };
-  }
-};
-
-function getShadingPatternFromIR(raw) {
-  var shadingIR = ShadingIRs[raw[0]];
-
-  if (!shadingIR) {
-    throw new Error("Unknown IR type: ".concat(raw[0]));
-  }
-
-  return shadingIR.fromIR(raw);
-}
-
-var TilingPattern = function TilingPatternClosure() {
-  var PaintType = {
-    COLORED: 1,
-    UNCOLORED: 2
-  };
-  var MAX_PATTERN_SIZE = 3000;
-
-  function TilingPattern(IR, color, ctx, canvasGraphicsFactory, baseTransform) {
-    this.operatorList = IR[2];
-    this.matrix = IR[3] || [1, 0, 0, 1, 0, 0];
-    this.bbox = IR[4];
-    this.xstep = IR[5];
-    this.ystep = IR[6];
-    this.paintType = IR[7];
-    this.tilingType = IR[8];
-    this.color = color;
-    this.canvasGraphicsFactory = canvasGraphicsFactory;
-    this.baseTransform = baseTransform;
-    this.type = 'Pattern';
-    this.ctx = ctx;
-  }
-
-  TilingPattern.prototype = {
-    createPatternCanvas: function TilinPattern_createPatternCanvas(owner) {
-      var operatorList = this.operatorList;
-      var bbox = this.bbox;
-      var xstep = this.xstep;
-      var ystep = this.ystep;
-      var paintType = this.paintType;
-      var tilingType = this.tilingType;
-      var color = this.color;
-      var canvasGraphicsFactory = this.canvasGraphicsFactory;
-      (0, _util.info)('TilingType: ' + tilingType);
-      var x0 = bbox[0],
-          y0 = bbox[1],
-          x1 = bbox[2],
-          y1 = bbox[3];
-
-      var matrixScale = _util.Util.singularValueDecompose2dScale(this.matrix);
-
-      var curMatrixScale = _util.Util.singularValueDecompose2dScale(this.baseTransform);
-
-      var combinedScale = [matrixScale[0] * curMatrixScale[0], matrixScale[1] * curMatrixScale[1]];
-      var dimx = this.getSizeAndScale(xstep, this.ctx.canvas.width, combinedScale[0]);
-      var dimy = this.getSizeAndScale(ystep, this.ctx.canvas.height, combinedScale[1]);
-      var tmpCanvas = owner.cachedCanvases.getCanvas('pattern', dimx.size, dimy.size, true);
-      var tmpCtx = tmpCanvas.context;
-      var graphics = canvasGraphicsFactory.createCanvasGraphics(tmpCtx);
-      graphics.groupLevel = owner.groupLevel;
-      this.setFillAndStrokeStyleToContext(graphics, paintType, color);
-      graphics.transform(dimx.scale, 0, 0, dimy.scale, 0, 0);
-      graphics.transform(1, 0, 0, 1, -x0, -y0);
-      this.clipBbox(graphics, bbox, x0, y0, x1, y1);
-      graphics.executeOperatorList(operatorList);
-      this.ctx.transform(1, 0, 0, 1, x0, y0);
-      this.ctx.scale(1 / dimx.scale, 1 / dimy.scale);
-      return tmpCanvas.canvas;
-    },
-    getSizeAndScale: function TilingPattern_getSizeAndScale(step, realOutputSize, scale) {
-      step = Math.abs(step);
-      var maxSize = Math.max(MAX_PATTERN_SIZE, realOutputSize);
-      var size = Math.ceil(step * scale);
-
-      if (size >= maxSize) {
-        size = maxSize;
-      } else {
-        scale = size / step;
-      }
-
-      return {
-        scale: scale,
-        size: size
-      };
-    },
-    clipBbox: function clipBbox(graphics, bbox, x0, y0, x1, y1) {
-      if (Array.isArray(bbox) && bbox.length === 4) {
-        var bboxWidth = x1 - x0;
-        var bboxHeight = y1 - y0;
-        graphics.ctx.rect(x0, y0, bboxWidth, bboxHeight);
-        graphics.clip();
-        graphics.endPath();
-      }
-    },
-    setFillAndStrokeStyleToContext: function setFillAndStrokeStyleToContext(graphics, paintType, color) {
-      var context = graphics.ctx,
-          current = graphics.current;
-
-      switch (paintType) {
-        case PaintType.COLORED:
-          var ctx = this.ctx;
-          context.fillStyle = ctx.fillStyle;
-          context.strokeStyle = ctx.strokeStyle;
-          current.fillColor = ctx.fillStyle;
-          current.strokeColor = ctx.strokeStyle;
-          break;
-
-        case PaintType.UNCOLORED:
-          var cssColor = _util.Util.makeCssRgb(color[0], color[1], color[2]);
-
-          context.fillStyle = cssColor;
-          context.strokeStyle = cssColor;
-          current.fillColor = cssColor;
-          current.strokeColor = cssColor;
-          break;
-
-        default:
-          throw new _util.FormatError("Unsupported paint type: ".concat(paintType));
-      }
-    },
-    getPattern: function TilingPattern_getPattern(ctx, owner) {
-      ctx = this.ctx;
-      ctx.setTransform.apply(ctx, this.baseTransform);
-      ctx.transform.apply(ctx, this.matrix);
-      var temporaryPatternCanvas = this.createPatternCanvas(owner);
-      return ctx.createPattern(temporaryPatternCanvas, 'repeat');
-    }
-  };
-  return TilingPattern;
-}();
-
-exports.TilingPattern = TilingPattern;
-
-/***/ }),
-/* 156 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.GlobalWorkerOptions = void 0;
-var GlobalWorkerOptions = Object.create(null);
-exports.GlobalWorkerOptions = GlobalWorkerOptions;
-GlobalWorkerOptions.workerPort = GlobalWorkerOptions.workerPort === undefined ? null : GlobalWorkerOptions.workerPort;
-GlobalWorkerOptions.workerSrc = GlobalWorkerOptions.workerSrc === undefined ? '' : GlobalWorkerOptions.workerSrc;
-
-/***/ }),
-/* 157 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.MessageHandler = MessageHandler;
-
-var _regenerator = _interopRequireDefault(__w_pdfjs_require__(148));
-
-var _util = __w_pdfjs_require__(1);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-function resolveCall(_x, _x2) {
-  return _resolveCall.apply(this, arguments);
-}
-
-function _resolveCall() {
-  _resolveCall = _asyncToGenerator(
-  /*#__PURE__*/
-  _regenerator["default"].mark(function _callee(fn, args) {
-    var thisArg,
-        _args = arguments;
-    return _regenerator["default"].wrap(function _callee$(_context) {
-      while (1) {
-        switch (_context.prev = _context.next) {
-          case 0:
-            thisArg = _args.length > 2 && _args[2] !== undefined ? _args[2] : null;
-
-            if (fn) {
-              _context.next = 3;
-              break;
-            }
-
-            return _context.abrupt("return", undefined);
-
-          case 3:
-            return _context.abrupt("return", fn.apply(thisArg, args));
-
-          case 4:
-          case "end":
-            return _context.stop();
-        }
-      }
-    }, _callee);
-  }));
-  return _resolveCall.apply(this, arguments);
-}
-
-function wrapReason(reason) {
-  if (_typeof(reason) !== 'object') {
-    return reason;
-  }
-
-  switch (reason.name) {
-    case 'AbortException':
-      return new _util.AbortException(reason.message);
-
-    case 'MissingPDFException':
-      return new _util.MissingPDFException(reason.message);
-
-    case 'UnexpectedResponseException':
-      return new _util.UnexpectedResponseException(reason.message, reason.status);
-
-    default:
-      return new _util.UnknownErrorException(reason.message, reason.details);
-  }
-}
-
-function makeReasonSerializable(reason) {
-  if (!(reason instanceof Error) || reason instanceof _util.AbortException || reason instanceof _util.MissingPDFException || reason instanceof _util.UnexpectedResponseException || reason instanceof _util.UnknownErrorException) {
-    return reason;
-  }
-
-  return new _util.UnknownErrorException(reason.message, reason.toString());
-}
-
-function resolveOrReject(capability, success, reason) {
-  if (success) {
-    capability.resolve();
-  } else {
-    capability.reject(reason);
-  }
-}
-
-function finalize(promise) {
-  return Promise.resolve(promise)["catch"](function () {});
-}
-
-function MessageHandler(sourceName, targetName, comObj) {
-  var _this = this;
-
-  this.sourceName = sourceName;
-  this.targetName = targetName;
-  this.comObj = comObj;
-  this.callbackId = 1;
-  this.streamId = 1;
-  this.postMessageTransfers = true;
-  this.streamSinks = Object.create(null);
-  this.streamControllers = Object.create(null);
-  var callbacksCapabilities = this.callbacksCapabilities = Object.create(null);
-  var ah = this.actionHandler = Object.create(null);
-
-  this._onComObjOnMessage = function (event) {
-    var data = event.data;
-
-    if (data.targetName !== _this.sourceName) {
-      return;
-    }
-
-    if (data.stream) {
-      _this._processStreamMessage(data);
-    } else if (data.isReply) {
-      var callbackId = data.callbackId;
-
-      if (data.callbackId in callbacksCapabilities) {
-        var callback = callbacksCapabilities[callbackId];
-        delete callbacksCapabilities[callbackId];
-
-        if ('error' in data) {
-          callback.reject(wrapReason(data.error));
-        } else {
-          callback.resolve(data.data);
-        }
-      } else {
-        throw new Error("Cannot resolve callback ".concat(callbackId));
-      }
-    } else if (data.action in ah) {
-      var action = ah[data.action];
-
-      if (data.callbackId) {
-        var _sourceName = _this.sourceName;
-        var _targetName = data.sourceName;
-        Promise.resolve().then(function () {
-          return action[0].call(action[1], data.data);
-        }).then(function (result) {
-          comObj.postMessage({
-            sourceName: _sourceName,
-            targetName: _targetName,
-            isReply: true,
-            callbackId: data.callbackId,
-            data: result
-          });
-        }, function (reason) {
-          comObj.postMessage({
-            sourceName: _sourceName,
-            targetName: _targetName,
-            isReply: true,
-            callbackId: data.callbackId,
-            error: makeReasonSerializable(reason)
-          });
-        });
-      } else if (data.streamId) {
-        _this._createStreamSink(data);
-      } else {
-        action[0].call(action[1], data.data);
-      }
-    } else {
-      throw new Error("Unknown action from worker: ".concat(data.action));
-    }
-  };
-
-  comObj.addEventListener('message', this._onComObjOnMessage);
-}
-
-MessageHandler.prototype = {
-  on: function on(actionName, handler, scope) {
-    var ah = this.actionHandler;
-
-    if (ah[actionName]) {
-      throw new Error("There is already an actionName called \"".concat(actionName, "\""));
-    }
-
-    ah[actionName] = [handler, scope];
-  },
-  send: function send(actionName, data, transfers) {
-    var message = {
-      sourceName: this.sourceName,
-      targetName: this.targetName,
-      action: actionName,
-      data: data
-    };
-    this.postMessage(message, transfers);
-  },
-  sendWithPromise: function sendWithPromise(actionName, data, transfers) {
-    var callbackId = this.callbackId++;
-    var message = {
-      sourceName: this.sourceName,
-      targetName: this.targetName,
-      action: actionName,
-      data: data,
-      callbackId: callbackId
-    };
-    var capability = (0, _util.createPromiseCapability)();
-    this.callbacksCapabilities[callbackId] = capability;
-
-    try {
-      this.postMessage(message, transfers);
-    } catch (e) {
-      capability.reject(e);
-    }
-
-    return capability.promise;
-  },
-  sendWithStream: function sendWithStream(actionName, data, queueingStrategy, transfers) {
-    var _this2 = this;
-
-    var streamId = this.streamId++;
-    var sourceName = this.sourceName;
-    var targetName = this.targetName;
-    return new _util.ReadableStream({
-      start: function start(controller) {
-        var startCapability = (0, _util.createPromiseCapability)();
-        _this2.streamControllers[streamId] = {
-          controller: controller,
-          startCall: startCapability,
-          isClosed: false
-        };
-
-        _this2.postMessage({
-          sourceName: sourceName,
-          targetName: targetName,
-          action: actionName,
-          streamId: streamId,
-          data: data,
-          desiredSize: controller.desiredSize
-        });
-
-        return startCapability.promise;
-      },
-      pull: function pull(controller) {
-        var pullCapability = (0, _util.createPromiseCapability)();
-        _this2.streamControllers[streamId].pullCall = pullCapability;
-
-        _this2.postMessage({
-          sourceName: sourceName,
-          targetName: targetName,
-          stream: 'pull',
-          streamId: streamId,
-          desiredSize: controller.desiredSize
-        });
-
-        return pullCapability.promise;
-      },
-      cancel: function cancel(reason) {
-        var cancelCapability = (0, _util.createPromiseCapability)();
-        _this2.streamControllers[streamId].cancelCall = cancelCapability;
-        _this2.streamControllers[streamId].isClosed = true;
-
-        _this2.postMessage({
-          sourceName: sourceName,
-          targetName: targetName,
-          stream: 'cancel',
-          reason: reason,
-          streamId: streamId
-        });
-
-        return cancelCapability.promise;
-      }
-    }, queueingStrategy);
-  },
-  _createStreamSink: function _createStreamSink(data) {
-    var _this3 = this;
-
-    var self = this;
-    var action = this.actionHandler[data.action];
-    var streamId = data.streamId;
-    var desiredSize = data.desiredSize;
-    var sourceName = this.sourceName;
-    var targetName = data.sourceName;
-    var capability = (0, _util.createPromiseCapability)();
-
-    var sendStreamRequest = function sendStreamRequest(_ref) {
-      var stream = _ref.stream,
-          chunk = _ref.chunk,
-          transfers = _ref.transfers,
-          success = _ref.success,
-          reason = _ref.reason;
-
-      _this3.postMessage({
-        sourceName: sourceName,
-        targetName: targetName,
-        stream: stream,
-        streamId: streamId,
-        chunk: chunk,
-        success: success,
-        reason: reason
-      }, transfers);
-    };
-
-    var streamSink = {
-      enqueue: function enqueue(chunk) {
-        var size = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-        var transfers = arguments.length > 2 ? arguments[2] : undefined;
-
-        if (this.isCancelled) {
-          return;
-        }
-
-        var lastDesiredSize = this.desiredSize;
-        this.desiredSize -= size;
-
-        if (lastDesiredSize > 0 && this.desiredSize <= 0) {
-          this.sinkCapability = (0, _util.createPromiseCapability)();
-          this.ready = this.sinkCapability.promise;
-        }
-
-        sendStreamRequest({
-          stream: 'enqueue',
-          chunk: chunk,
-          transfers: transfers
-        });
-      },
-      close: function close() {
-        if (this.isCancelled) {
-          return;
-        }
-
-        this.isCancelled = true;
-        sendStreamRequest({
-          stream: 'close'
-        });
-        delete self.streamSinks[streamId];
-      },
-      error: function error(reason) {
-        if (this.isCancelled) {
-          return;
-        }
-
-        this.isCancelled = true;
-        sendStreamRequest({
-          stream: 'error',
-          reason: reason
-        });
-      },
-      sinkCapability: capability,
-      onPull: null,
-      onCancel: null,
-      isCancelled: false,
-      desiredSize: desiredSize,
-      ready: null
-    };
-    streamSink.sinkCapability.resolve();
-    streamSink.ready = streamSink.sinkCapability.promise;
-    this.streamSinks[streamId] = streamSink;
-    resolveCall(action[0], [data.data, streamSink], action[1]).then(function () {
-      sendStreamRequest({
-        stream: 'start_complete',
-        success: true
-      });
-    }, function (reason) {
-      sendStreamRequest({
-        stream: 'start_complete',
-        success: false,
-        reason: reason
-      });
-    });
-  },
-  _processStreamMessage: function _processStreamMessage(data) {
-    var _this4 = this;
-
-    var sourceName = this.sourceName;
-    var targetName = data.sourceName;
-    var streamId = data.streamId;
-
-    var sendStreamResponse = function sendStreamResponse(_ref2) {
-      var stream = _ref2.stream,
-          success = _ref2.success,
-          reason = _ref2.reason;
-
-      _this4.comObj.postMessage({
-        sourceName: sourceName,
-        targetName: targetName,
-        stream: stream,
-        success: success,
-        streamId: streamId,
-        reason: reason
-      });
-    };
-
-    var deleteStreamController = function deleteStreamController() {
-      Promise.all([_this4.streamControllers[data.streamId].startCall, _this4.streamControllers[data.streamId].pullCall, _this4.streamControllers[data.streamId].cancelCall].map(function (capability) {
-        return capability && finalize(capability.promise);
-      })).then(function () {
-        delete _this4.streamControllers[data.streamId];
-      });
-    };
-
-    switch (data.stream) {
-      case 'start_complete':
-        resolveOrReject(this.streamControllers[data.streamId].startCall, data.success, wrapReason(data.reason));
-        break;
-
-      case 'pull_complete':
-        resolveOrReject(this.streamControllers[data.streamId].pullCall, data.success, wrapReason(data.reason));
-        break;
-
-      case 'pull':
-        if (!this.streamSinks[data.streamId]) {
-          sendStreamResponse({
-            stream: 'pull_complete',
-            success: true
-          });
-          break;
-        }
-
-        if (this.streamSinks[data.streamId].desiredSize <= 0 && data.desiredSize > 0) {
-          this.streamSinks[data.streamId].sinkCapability.resolve();
-        }
-
-        this.streamSinks[data.streamId].desiredSize = data.desiredSize;
-        resolveCall(this.streamSinks[data.streamId].onPull).then(function () {
-          sendStreamResponse({
-            stream: 'pull_complete',
-            success: true
-          });
-        }, function (reason) {
-          sendStreamResponse({
-            stream: 'pull_complete',
-            success: false,
-            reason: reason
-          });
-        });
-        break;
-
-      case 'enqueue':
-        (0, _util.assert)(this.streamControllers[data.streamId], 'enqueue should have stream controller');
-
-        if (!this.streamControllers[data.streamId].isClosed) {
-          this.streamControllers[data.streamId].controller.enqueue(data.chunk);
-        }
-
-        break;
-
-      case 'close':
-        (0, _util.assert)(this.streamControllers[data.streamId], 'close should have stream controller');
-
-        if (this.streamControllers[data.streamId].isClosed) {
-          break;
-        }
-
-        this.streamControllers[data.streamId].isClosed = true;
-        this.streamControllers[data.streamId].controller.close();
-        deleteStreamController();
-        break;
-
-      case 'error':
-        (0, _util.assert)(this.streamControllers[data.streamId], 'error should have stream controller');
-        this.streamControllers[data.streamId].controller.error(wrapReason(data.reason));
-        deleteStreamController();
-        break;
-
-      case 'cancel_complete':
-        resolveOrReject(this.streamControllers[data.streamId].cancelCall, data.success, wrapReason(data.reason));
-        deleteStreamController();
-        break;
-
-      case 'cancel':
-        if (!this.streamSinks[data.streamId]) {
-          break;
-        }
-
-        resolveCall(this.streamSinks[data.streamId].onCancel, [wrapReason(data.reason)]).then(function () {
-          sendStreamResponse({
-            stream: 'cancel_complete',
-            success: true
-          });
-        }, function (reason) {
-          sendStreamResponse({
-            stream: 'cancel_complete',
-            success: false,
-            reason: reason
-          });
-        });
-        this.streamSinks[data.streamId].sinkCapability.reject(wrapReason(data.reason));
-        this.streamSinks[data.streamId].isCancelled = true;
-        delete this.streamSinks[data.streamId];
-        break;
-
-      default:
-        throw new Error('Unexpected stream case');
-    }
-  },
-  postMessage: function postMessage(message, transfers) {
-    if (transfers && this.postMessageTransfers) {
-      this.comObj.postMessage(message, transfers);
-    } else {
-      this.comObj.postMessage(message);
-    }
-  },
-  destroy: function destroy() {
-    this.comObj.removeEventListener('message', this._onComObjOnMessage);
-  }
-};
-
-/***/ }),
-/* 158 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.Metadata = void 0;
-
-var _util = __w_pdfjs_require__(1);
-
-var _xml_parser = __w_pdfjs_require__(159);
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-var Metadata =
-/*#__PURE__*/
-function () {
-  function Metadata(data) {
-    _classCallCheck(this, Metadata);
-
-    (0, _util.assert)(typeof data === 'string', 'Metadata: input is not a string');
-    data = this._repair(data);
-    var parser = new _xml_parser.SimpleXMLParser();
-    var xmlDocument = parser.parseFromString(data);
-    this._metadata = Object.create(null);
-
-    if (xmlDocument) {
-      this._parse(xmlDocument);
-    }
-  }
-
-  _createClass(Metadata, [{
-    key: "_repair",
-    value: function _repair(data) {
-      return data.replace(/^([^<]+)/, '').replace(/>\\376\\377([^<]+)/g, function (all, codes) {
-        var bytes = codes.replace(/\\([0-3])([0-7])([0-7])/g, function (code, d1, d2, d3) {
-          return String.fromCharCode(d1 * 64 + d2 * 8 + d3 * 1);
-        }).replace(/&(amp|apos|gt|lt|quot);/g, function (str, name) {
-          switch (name) {
-            case 'amp':
-              return '&';
-
-            case 'apos':
-              return '\'';
-
-            case 'gt':
-              return '>';
-
-            case 'lt':
-              return '<';
-
-            case 'quot':
-              return '\"';
-          }
-
-          throw new Error("_repair: ".concat(name, " isn't defined."));
-        });
-        var chars = '';
-
-        for (var i = 0, ii = bytes.length; i < ii; i += 2) {
-          var code = bytes.charCodeAt(i) * 256 + bytes.charCodeAt(i + 1);
-
-          if (code >= 32 && code < 127 && code !== 60 && code !== 62 && code !== 38) {
-            chars += String.fromCharCode(code);
-          } else {
-            chars += '&#x' + (0x10000 + code).toString(16).substring(1) + ';';
-          }
-        }
-
-        return '>' + chars;
-      });
-    }
-  }, {
-    key: "_parse",
-    value: function _parse(xmlDocument) {
-      var rdf = xmlDocument.documentElement;
-
-      if (rdf.nodeName.toLowerCase() !== 'rdf:rdf') {
-        rdf = rdf.firstChild;
-
-        while (rdf && rdf.nodeName.toLowerCase() !== 'rdf:rdf') {
-          rdf = rdf.nextSibling;
-        }
-      }
-
-      var nodeName = rdf ? rdf.nodeName.toLowerCase() : null;
-
-      if (!rdf || nodeName !== 'rdf:rdf' || !rdf.hasChildNodes()) {
-        return;
-      }
-
-      var children = rdf.childNodes;
-
-      for (var i = 0, ii = children.length; i < ii; i++) {
-        var desc = children[i];
-
-        if (desc.nodeName.toLowerCase() !== 'rdf:description') {
-          continue;
-        }
-
-        for (var j = 0, jj = desc.childNodes.length; j < jj; j++) {
-          if (desc.childNodes[j].nodeName.toLowerCase() !== '#text') {
-            var entry = desc.childNodes[j];
-            var name = entry.nodeName.toLowerCase();
-            this._metadata[name] = entry.textContent.trim();
-          }
-        }
-      }
-    }
-  }, {
-    key: "get",
-    value: function get(name) {
-      var data = this._metadata[name];
-      return typeof data !== 'undefined' ? data : null;
-    }
-  }, {
-    key: "getAll",
-    value: function getAll() {
-      return this._metadata;
-    }
-  }, {
-    key: "has",
-    value: function has(name) {
-      return typeof this._metadata[name] !== 'undefined';
-    }
-  }]);
-
-  return Metadata;
-}();
-
-exports.Metadata = Metadata;
-
-/***/ }),
-/* 159 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.SimpleXMLParser = void 0;
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
-
-function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-var XMLParserErrorCode = {
-  NoError: 0,
-  EndOfDocument: -1,
-  UnterminatedCdat: -2,
-  UnterminatedXmlDeclaration: -3,
-  UnterminatedDoctypeDeclaration: -4,
-  UnterminatedComment: -5,
-  MalformedElement: -6,
-  OutOfMemory: -7,
-  UnterminatedAttributeValue: -8,
-  UnterminatedElement: -9,
-  ElementNeverBegun: -10
-};
-
-function isWhitespace(s, index) {
-  var ch = s[index];
-  return ch === ' ' || ch === '\n' || ch === '\r' || ch === '\t';
-}
-
-function isWhitespaceString(s) {
-  for (var i = 0, ii = s.length; i < ii; i++) {
-    if (!isWhitespace(s, i)) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-var XMLParserBase =
-/*#__PURE__*/
-function () {
-  function XMLParserBase() {
-    _classCallCheck(this, XMLParserBase);
-  }
-
-  _createClass(XMLParserBase, [{
-    key: "_resolveEntities",
-    value: function _resolveEntities(s) {
-      var _this = this;
-
-      return s.replace(/&([^;]+);/g, function (all, entity) {
-        if (entity.substring(0, 2) === '#x') {
-          return String.fromCharCode(parseInt(entity.substring(2), 16));
-        } else if (entity.substring(0, 1) === '#') {
-          return String.fromCharCode(parseInt(entity.substring(1), 10));
-        }
-
-        switch (entity) {
-          case 'lt':
-            return '<';
-
-          case 'gt':
-            return '>';
-
-          case 'amp':
-            return '&';
-
-          case 'quot':
-            return '\"';
-        }
-
-        return _this.onResolveEntity(entity);
-      });
-    }
-  }, {
-    key: "_parseContent",
-    value: function _parseContent(s, start) {
-      var pos = start,
-          name,
-          attributes = [];
-
-      function skipWs() {
-        while (pos < s.length && isWhitespace(s, pos)) {
-          ++pos;
-        }
-      }
-
-      while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== '>' && s[pos] !== '/') {
-        ++pos;
-      }
-
-      name = s.substring(start, pos);
-      skipWs();
-
-      while (pos < s.length && s[pos] !== '>' && s[pos] !== '/' && s[pos] !== '?') {
-        skipWs();
-        var attrName = '',
-            attrValue = '';
-
-        while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== '=') {
-          attrName += s[pos];
-          ++pos;
-        }
-
-        skipWs();
-
-        if (s[pos] !== '=') {
-          return null;
-        }
-
-        ++pos;
-        skipWs();
-        var attrEndChar = s[pos];
-
-        if (attrEndChar !== '\"' && attrEndChar !== '\'') {
-          return null;
-        }
-
-        var attrEndIndex = s.indexOf(attrEndChar, ++pos);
-
-        if (attrEndIndex < 0) {
-          return null;
-        }
-
-        attrValue = s.substring(pos, attrEndIndex);
-        attributes.push({
-          name: attrName,
-          value: this._resolveEntities(attrValue)
-        });
-        pos = attrEndIndex + 1;
-        skipWs();
-      }
-
-      return {
-        name: name,
-        attributes: attributes,
-        parsed: pos - start
-      };
-    }
-  }, {
-    key: "_parseProcessingInstruction",
-    value: function _parseProcessingInstruction(s, start) {
-      var pos = start,
-          name,
-          value;
-
-      function skipWs() {
-        while (pos < s.length && isWhitespace(s, pos)) {
-          ++pos;
-        }
-      }
-
-      while (pos < s.length && !isWhitespace(s, pos) && s[pos] !== '>' && s[pos] !== '/') {
-        ++pos;
-      }
-
-      name = s.substring(start, pos);
-      skipWs();
-      var attrStart = pos;
-
-      while (pos < s.length && (s[pos] !== '?' || s[pos + 1] !== '>')) {
-        ++pos;
-      }
-
-      value = s.substring(attrStart, pos);
-      return {
-        name: name,
-        value: value,
-        parsed: pos - start
-      };
-    }
-  }, {
-    key: "parseXml",
-    value: function parseXml(s) {
-      var i = 0;
-
-      while (i < s.length) {
-        var ch = s[i];
-        var j = i;
-
-        if (ch === '<') {
-          ++j;
-          var ch2 = s[j];
-          var q = void 0;
-
-          switch (ch2) {
-            case '/':
-              ++j;
-              q = s.indexOf('>', j);
-
-              if (q < 0) {
-                this.onError(XMLParserErrorCode.UnterminatedElement);
-                return;
-              }
-
-              this.onEndElement(s.substring(j, q));
-              j = q + 1;
-              break;
-
-            case '?':
-              ++j;
-
-              var pi = this._parseProcessingInstruction(s, j);
-
-              if (s.substring(j + pi.parsed, j + pi.parsed + 2) !== '?>') {
-                this.onError(XMLParserErrorCode.UnterminatedXmlDeclaration);
-                return;
-              }
-
-              this.onPi(pi.name, pi.value);
-              j += pi.parsed + 2;
-              break;
-
-            case '!':
-              if (s.substring(j + 1, j + 3) === '--') {
-                q = s.indexOf('-->', j + 3);
-
-                if (q < 0) {
-                  this.onError(XMLParserErrorCode.UnterminatedComment);
-                  return;
-                }
-
-                this.onComment(s.substring(j + 3, q));
-                j = q + 3;
-              } else if (s.substring(j + 1, j + 8) === '[CDATA[') {
-                q = s.indexOf(']]>', j + 8);
-
-                if (q < 0) {
-                  this.onError(XMLParserErrorCode.UnterminatedCdat);
-                  return;
-                }
-
-                this.onCdata(s.substring(j + 8, q));
-                j = q + 3;
-              } else if (s.substring(j + 1, j + 8) === 'DOCTYPE') {
-                var q2 = s.indexOf('[', j + 8);
-                var complexDoctype = false;
-                q = s.indexOf('>', j + 8);
-
-                if (q < 0) {
-                  this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
-                  return;
-                }
-
-                if (q2 > 0 && q > q2) {
-                  q = s.indexOf(']>', j + 8);
-
-                  if (q < 0) {
-                    this.onError(XMLParserErrorCode.UnterminatedDoctypeDeclaration);
-                    return;
-                  }
-
-                  complexDoctype = true;
-                }
-
-                var doctypeContent = s.substring(j + 8, q + (complexDoctype ? 1 : 0));
-                this.onDoctype(doctypeContent);
-                j = q + (complexDoctype ? 2 : 1);
-              } else {
-                this.onError(XMLParserErrorCode.MalformedElement);
-                return;
-              }
-
-              break;
-
-            default:
-              var content = this._parseContent(s, j);
-
-              if (content === null) {
-                this.onError(XMLParserErrorCode.MalformedElement);
-                return;
-              }
-
-              var isClosed = false;
-
-              if (s.substring(j + content.parsed, j + content.parsed + 2) === '/>') {
-                isClosed = true;
-              } else if (s.substring(j + content.parsed, j + content.parsed + 1) !== '>') {
-                this.onError(XMLParserErrorCode.UnterminatedElement);
-                return;
-              }
-
-              this.onBeginElement(content.name, content.attributes, isClosed);
-              j += content.parsed + (isClosed ? 2 : 1);
-              break;
-          }
-        } else {
-          while (j < s.length && s[j] !== '<') {
-            j++;
-          }
-
-          var text = s.substring(i, j);
-          this.onText(this._resolveEntities(text));
-        }
-
-        i = j;
-      }
-    }
-  }, {
-    key: "onResolveEntity",
-    value: function onResolveEntity(name) {
-      return "&".concat(name, ";");
-    }
-  }, {
-    key: "onPi",
-    value: function onPi(name, value) {}
-  }, {
-    key: "onComment",
-    value: function onComment(text) {}
-  }, {
-    key: "onCdata",
-    value: function onCdata(text) {}
-  }, {
-    key: "onDoctype",
-    value: function onDoctype(doctypeContent) {}
-  }, {
-    key: "onText",
-    value: function onText(text) {}
-  }, {
-    key: "onBeginElement",
-    value: function onBeginElement(name, attributes, isEmpty) {}
-  }, {
-    key: "onEndElement",
-    value: function onEndElement(name) {}
-  }, {
-    key: "onError",
-    value: function onError(code) {}
-  }]);
-
-  return XMLParserBase;
-}();
-
-var SimpleDOMNode =
-/*#__PURE__*/
-function () {
-  function SimpleDOMNode(nodeName, nodeValue) {
-    _classCallCheck(this, SimpleDOMNode);
-
-    this.nodeName = nodeName;
-    this.nodeValue = nodeValue;
-    Object.defineProperty(this, 'parentNode', {
-      value: null,
-      writable: true
-    });
-  }
-
-  _createClass(SimpleDOMNode, [{
-    key: "hasChildNodes",
-    value: function hasChildNodes() {
-      return this.childNodes && this.childNodes.length > 0;
-    }
-  }, {
-    key: "firstChild",
-    get: function get() {
-      return this.childNodes && this.childNodes[0];
-    }
-  }, {
-    key: "nextSibling",
-    get: function get() {
-      var childNodes = this.parentNode.childNodes;
-
-      if (!childNodes) {
-        return undefined;
-      }
-
-      var index = childNodes.indexOf(this);
-
-      if (index === -1) {
-        return undefined;
-      }
-
-      return childNodes[index + 1];
-    }
-  }, {
-    key: "textContent",
-    get: function get() {
-      if (!this.childNodes) {
-        return this.nodeValue || '';
-      }
-
-      return this.childNodes.map(function (child) {
-        return child.textContent;
-      }).join('');
-    }
-  }]);
-
-  return SimpleDOMNode;
-}();
-
-var SimpleXMLParser =
-/*#__PURE__*/
-function (_XMLParserBase) {
-  _inherits(SimpleXMLParser, _XMLParserBase);
-
-  function SimpleXMLParser() {
-    var _this2;
-
-    _classCallCheck(this, SimpleXMLParser);
-
-    _this2 = _possibleConstructorReturn(this, _getPrototypeOf(SimpleXMLParser).call(this));
-    _this2._currentFragment = null;
-    _this2._stack = null;
-    _this2._errorCode = XMLParserErrorCode.NoError;
-    return _this2;
-  }
-
-  _createClass(SimpleXMLParser, [{
-    key: "parseFromString",
-    value: function parseFromString(data) {
-      this._currentFragment = [];
-      this._stack = [];
-      this._errorCode = XMLParserErrorCode.NoError;
-      this.parseXml(data);
-
-      if (this._errorCode !== XMLParserErrorCode.NoError) {
-        return undefined;
-      }
-
-      var _this$_currentFragmen = _slicedToArray(this._currentFragment, 1),
-          documentElement = _this$_currentFragmen[0];
-
-      if (!documentElement) {
-        return undefined;
-      }
-
-      return {
-        documentElement: documentElement
-      };
-    }
-  }, {
-    key: "onResolveEntity",
-    value: function onResolveEntity(name) {
-      switch (name) {
-        case 'apos':
-          return '\'';
-      }
-
-      return _get(_getPrototypeOf(SimpleXMLParser.prototype), "onResolveEntity", this).call(this, name);
-    }
-  }, {
-    key: "onText",
-    value: function onText(text) {
-      if (isWhitespaceString(text)) {
-        return;
-      }
-
-      var node = new SimpleDOMNode('#text', text);
-
-      this._currentFragment.push(node);
-    }
-  }, {
-    key: "onCdata",
-    value: function onCdata(text) {
-      var node = new SimpleDOMNode('#text', text);
-
-      this._currentFragment.push(node);
-    }
-  }, {
-    key: "onBeginElement",
-    value: function onBeginElement(name, attributes, isEmpty) {
-      var node = new SimpleDOMNode(name);
-      node.childNodes = [];
-
-      this._currentFragment.push(node);
-
-      if (isEmpty) {
-        return;
-      }
-
-      this._stack.push(this._currentFragment);
-
-      this._currentFragment = node.childNodes;
-    }
-  }, {
-    key: "onEndElement",
-    value: function onEndElement(name) {
-      this._currentFragment = this._stack.pop() || [];
-      var lastElement = this._currentFragment[this._currentFragment.length - 1];
-
-      if (!lastElement) {
-        return;
-      }
-
-      for (var i = 0, ii = lastElement.childNodes.length; i < ii; i++) {
-        lastElement.childNodes[i].parentNode = lastElement;
-      }
-    }
-  }, {
-    key: "onError",
-    value: function onError(code) {
-      this._errorCode = code;
-    }
-  }]);
-
-  return SimpleXMLParser;
-}(XMLParserBase);
-
-exports.SimpleXMLParser = SimpleXMLParser;
-
-/***/ }),
-/* 160 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.PDFDataTransportStream = void 0;
-
-var _regenerator = _interopRequireDefault(__w_pdfjs_require__(148));
-
-var _util = __w_pdfjs_require__(1);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-var PDFDataTransportStream =
-/*#__PURE__*/
-function () {
-  function PDFDataTransportStream(params, pdfDataRangeTransport) {
-    var _this = this;
-
-    _classCallCheck(this, PDFDataTransportStream);
-
-    (0, _util.assert)(pdfDataRangeTransport);
-    this._queuedChunks = [];
-    this._progressiveDone = params.progressiveDone || false;
-    var initialData = params.initialData;
-
-    if (initialData && initialData.length > 0) {
-      var buffer = new Uint8Array(initialData).buffer;
-
-      this._queuedChunks.push(buffer);
-    }
-
-    this._pdfDataRangeTransport = pdfDataRangeTransport;
-    this._isStreamingSupported = !params.disableStream;
-    this._isRangeSupported = !params.disableRange;
-    this._contentLength = params.length;
-    this._fullRequestReader = null;
-    this._rangeReaders = [];
-
-    this._pdfDataRangeTransport.addRangeListener(function (begin, chunk) {
-      _this._onReceiveData({
-        begin: begin,
-        chunk: chunk
-      });
-    });
-
-    this._pdfDataRangeTransport.addProgressListener(function (loaded, total) {
-      _this._onProgress({
-        loaded: loaded,
-        total: total
-      });
-    });
-
-    this._pdfDataRangeTransport.addProgressiveReadListener(function (chunk) {
-      _this._onReceiveData({
-        chunk: chunk
-      });
-    });
-
-    this._pdfDataRangeTransport.addProgressiveDoneListener(function () {
-      _this._onProgressiveDone();
-    });
-
-    this._pdfDataRangeTransport.transportReady();
-  }
-
-  _createClass(PDFDataTransportStream, [{
-    key: "_onReceiveData",
-    value: function _onReceiveData(args) {
-      var buffer = new Uint8Array(args.chunk).buffer;
-
-      if (args.begin === undefined) {
-        if (this._fullRequestReader) {
-          this._fullRequestReader._enqueue(buffer);
-        } else {
-          this._queuedChunks.push(buffer);
-        }
-      } else {
-        var found = this._rangeReaders.some(function (rangeReader) {
-          if (rangeReader._begin !== args.begin) {
-            return false;
-          }
-
-          rangeReader._enqueue(buffer);
-
-          return true;
-        });
-
-        (0, _util.assert)(found);
-      }
-    }
-  }, {
-    key: "_onProgress",
-    value: function _onProgress(evt) {
-      if (evt.total === undefined) {
-        var firstReader = this._rangeReaders[0];
-
-        if (firstReader && firstReader.onProgress) {
-          firstReader.onProgress({
-            loaded: evt.loaded
-          });
-        }
-      } else {
-        var fullReader = this._fullRequestReader;
-
-        if (fullReader && fullReader.onProgress) {
-          fullReader.onProgress({
-            loaded: evt.loaded,
-            total: evt.total
-          });
-        }
-      }
-    }
-  }, {
-    key: "_onProgressiveDone",
-    value: function _onProgressiveDone() {
-      if (this._fullRequestReader) {
-        this._fullRequestReader.progressiveDone();
-      }
-
-      this._progressiveDone = true;
-    }
-  }, {
-    key: "_removeRangeReader",
-    value: function _removeRangeReader(reader) {
-      var i = this._rangeReaders.indexOf(reader);
-
-      if (i >= 0) {
-        this._rangeReaders.splice(i, 1);
-      }
-    }
-  }, {
-    key: "getFullReader",
-    value: function getFullReader() {
-      (0, _util.assert)(!this._fullRequestReader);
-      var queuedChunks = this._queuedChunks;
-      this._queuedChunks = null;
-      return new PDFDataTransportStreamReader(this, queuedChunks, this._progressiveDone);
-    }
-  }, {
-    key: "getRangeReader",
-    value: function getRangeReader(begin, end) {
-      if (end <= this._progressiveDataLength) {
-        return null;
-      }
-
-      var reader = new PDFDataTransportStreamRangeReader(this, begin, end);
-
-      this._pdfDataRangeTransport.requestDataRange(begin, end);
-
-      this._rangeReaders.push(reader);
-
-      return reader;
-    }
-  }, {
-    key: "cancelAllRequests",
-    value: function cancelAllRequests(reason) {
-      if (this._fullRequestReader) {
-        this._fullRequestReader.cancel(reason);
-      }
-
-      var readers = this._rangeReaders.slice(0);
-
-      readers.forEach(function (rangeReader) {
-        rangeReader.cancel(reason);
-      });
-
-      this._pdfDataRangeTransport.abort();
-    }
-  }, {
-    key: "_progressiveDataLength",
-    get: function get() {
-      return this._fullRequestReader ? this._fullRequestReader._loaded : 0;
-    }
-  }]);
-
-  return PDFDataTransportStream;
-}();
-
-exports.PDFDataTransportStream = PDFDataTransportStream;
-
-var PDFDataTransportStreamReader =
-/*#__PURE__*/
-function () {
-  function PDFDataTransportStreamReader(stream, queuedChunks) {
-    var progressiveDone = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-
-    _classCallCheck(this, PDFDataTransportStreamReader);
-
-    this._stream = stream;
-    this._done = progressiveDone || false;
-    this._filename = null;
-    this._queuedChunks = queuedChunks || [];
-    this._loaded = 0;
-    var _iteratorNormalCompletion = true;
-    var _didIteratorError = false;
-    var _iteratorError = undefined;
-
-    try {
-      for (var _iterator = this._queuedChunks[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-        var chunk = _step.value;
-        this._loaded += chunk.byteLength;
-      }
-    } catch (err) {
-      _didIteratorError = true;
-      _iteratorError = err;
-    } finally {
-      try {
-        if (!_iteratorNormalCompletion && _iterator["return"] != null) {
-          _iterator["return"]();
-        }
-      } finally {
-        if (_didIteratorError) {
-          throw _iteratorError;
-        }
-      }
-    }
-
-    this._requests = [];
-    this._headersReady = Promise.resolve();
-    stream._fullRequestReader = this;
-    this.onProgress = null;
-  }
-
-  _createClass(PDFDataTransportStreamReader, [{
-    key: "_enqueue",
-    value: function _enqueue(chunk) {
-      if (this._done) {
-        return;
-      }
-
-      if (this._requests.length > 0) {
-        var requestCapability = this._requests.shift();
-
-        requestCapability.resolve({
-          value: chunk,
-          done: false
-        });
-      } else {
-        this._queuedChunks.push(chunk);
-      }
-
-      this._loaded += chunk.byteLength;
-    }
-  }, {
-    key: "read",
-    value: function () {
-      var _read = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator["default"].mark(function _callee() {
-        var chunk, requestCapability;
-        return _regenerator["default"].wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                if (!(this._queuedChunks.length > 0)) {
-                  _context.next = 3;
-                  break;
-                }
-
-                chunk = this._queuedChunks.shift();
-                return _context.abrupt("return", {
-                  value: chunk,
-                  done: false
-                });
-
-              case 3:
-                if (!this._done) {
-                  _context.next = 5;
-                  break;
-                }
-
-                return _context.abrupt("return", {
-                  value: undefined,
-                  done: true
-                });
-
-              case 5:
-                requestCapability = (0, _util.createPromiseCapability)();
-
-                this._requests.push(requestCapability);
-
-                return _context.abrupt("return", requestCapability.promise);
-
-              case 8:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this);
-      }));
-
-      function read() {
-        return _read.apply(this, arguments);
-      }
-
-      return read;
-    }()
-  }, {
-    key: "cancel",
-    value: function cancel(reason) {
-      this._done = true;
-
-      this._requests.forEach(function (requestCapability) {
-        requestCapability.resolve({
-          value: undefined,
-          done: true
-        });
-      });
-
-      this._requests = [];
-    }
-  }, {
-    key: "progressiveDone",
-    value: function progressiveDone() {
-      if (this._done) {
-        return;
-      }
-
-      this._done = true;
-    }
-  }, {
-    key: "headersReady",
-    get: function get() {
-      return this._headersReady;
-    }
-  }, {
-    key: "filename",
-    get: function get() {
-      return this._filename;
-    }
-  }, {
-    key: "isRangeSupported",
-    get: function get() {
-      return this._stream._isRangeSupported;
-    }
-  }, {
-    key: "isStreamingSupported",
-    get: function get() {
-      return this._stream._isStreamingSupported;
-    }
-  }, {
-    key: "contentLength",
-    get: function get() {
-      return this._stream._contentLength;
-    }
-  }]);
-
-  return PDFDataTransportStreamReader;
-}();
-
-var PDFDataTransportStreamRangeReader =
-/*#__PURE__*/
-function () {
-  function PDFDataTransportStreamRangeReader(stream, begin, end) {
-    _classCallCheck(this, PDFDataTransportStreamRangeReader);
-
-    this._stream = stream;
-    this._begin = begin;
-    this._end = end;
-    this._queuedChunk = null;
-    this._requests = [];
-    this._done = false;
-    this.onProgress = null;
-  }
-
-  _createClass(PDFDataTransportStreamRangeReader, [{
-    key: "_enqueue",
-    value: function _enqueue(chunk) {
-      if (this._done) {
-        return;
-      }
-
-      if (this._requests.length === 0) {
-        this._queuedChunk = chunk;
-      } else {
-        var requestsCapability = this._requests.shift();
-
-        requestsCapability.resolve({
-          value: chunk,
-          done: false
-        });
-
-        this._requests.forEach(function (requestCapability) {
-          requestCapability.resolve({
-            value: undefined,
-            done: true
-          });
-        });
-
-        this._requests = [];
-      }
-
-      this._done = true;
-
-      this._stream._removeRangeReader(this);
-    }
-  }, {
-    key: "read",
-    value: function () {
-      var _read2 = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator["default"].mark(function _callee2() {
-        var chunk, requestCapability;
-        return _regenerator["default"].wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                if (!this._queuedChunk) {
-                  _context2.next = 4;
-                  break;
-                }
-
-                chunk = this._queuedChunk;
-                this._queuedChunk = null;
-                return _context2.abrupt("return", {
-                  value: chunk,
-                  done: false
-                });
-
-              case 4:
-                if (!this._done) {
-                  _context2.next = 6;
-                  break;
-                }
-
-                return _context2.abrupt("return", {
-                  value: undefined,
-                  done: true
-                });
-
-              case 6:
-                requestCapability = (0, _util.createPromiseCapability)();
-
-                this._requests.push(requestCapability);
-
-                return _context2.abrupt("return", requestCapability.promise);
-
-              case 9:
-              case "end":
-                return _context2.stop();
-            }
-          }
-        }, _callee2, this);
-      }));
-
-      function read() {
-        return _read2.apply(this, arguments);
-      }
-
-      return read;
-    }()
-  }, {
-    key: "cancel",
-    value: function cancel(reason) {
-      this._done = true;
-
-      this._requests.forEach(function (requestCapability) {
-        requestCapability.resolve({
-          value: undefined,
-          done: true
-        });
-      });
-
-      this._requests = [];
-
-      this._stream._removeRangeReader(this);
-    }
-  }, {
-    key: "isStreamingSupported",
-    get: function get() {
-      return false;
-    }
-  }]);
-
-  return PDFDataTransportStreamRangeReader;
-}();
-
-/***/ }),
-/* 161 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.WebGLContext = void 0;
-
-var _util = __w_pdfjs_require__(1);
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-var WebGLContext =
-/*#__PURE__*/
-function () {
-  function WebGLContext(_ref) {
-    var _ref$enable = _ref.enable,
-        enable = _ref$enable === void 0 ? false : _ref$enable;
-
-    _classCallCheck(this, WebGLContext);
-
-    this._enabled = enable === true;
-  }
-
-  _createClass(WebGLContext, [{
-    key: "composeSMask",
-    value: function composeSMask(_ref2) {
-      var layer = _ref2.layer,
-          mask = _ref2.mask,
-          properties = _ref2.properties;
-      return WebGLUtils.composeSMask(layer, mask, properties);
-    }
-  }, {
-    key: "drawFigures",
-    value: function drawFigures(_ref3) {
-      var width = _ref3.width,
-          height = _ref3.height,
-          backgroundColor = _ref3.backgroundColor,
-          figures = _ref3.figures,
-          context = _ref3.context;
-      return WebGLUtils.drawFigures(width, height, backgroundColor, figures, context);
-    }
-  }, {
-    key: "clear",
-    value: function clear() {
-      WebGLUtils.cleanup();
-    }
-  }, {
-    key: "isEnabled",
-    get: function get() {
-      var enabled = this._enabled;
-
-      if (enabled) {
-        enabled = WebGLUtils.tryInitGL();
-      }
-
-      return (0, _util.shadow)(this, 'isEnabled', enabled);
-    }
-  }]);
-
-  return WebGLContext;
-}();
-
-exports.WebGLContext = WebGLContext;
-
-var WebGLUtils = function WebGLUtilsClosure() {
-  function loadShader(gl, code, shaderType) {
-    var shader = gl.createShader(shaderType);
-    gl.shaderSource(shader, code);
-    gl.compileShader(shader);
-    var compiled = gl.getShaderParameter(shader, gl.COMPILE_STATUS);
-
-    if (!compiled) {
-      var errorMsg = gl.getShaderInfoLog(shader);
-      throw new Error('Error during shader compilation: ' + errorMsg);
-    }
-
-    return shader;
-  }
-
-  function createVertexShader(gl, code) {
-    return loadShader(gl, code, gl.VERTEX_SHADER);
-  }
-
-  function createFragmentShader(gl, code) {
-    return loadShader(gl, code, gl.FRAGMENT_SHADER);
-  }
-
-  function createProgram(gl, shaders) {
-    var program = gl.createProgram();
-
-    for (var i = 0, ii = shaders.length; i < ii; ++i) {
-      gl.attachShader(program, shaders[i]);
-    }
-
-    gl.linkProgram(program);
-    var linked = gl.getProgramParameter(program, gl.LINK_STATUS);
-
-    if (!linked) {
-      var errorMsg = gl.getProgramInfoLog(program);
-      throw new Error('Error during program linking: ' + errorMsg);
-    }
-
-    return program;
-  }
-
-  function createTexture(gl, image, textureId) {
-    gl.activeTexture(textureId);
-    var texture = gl.createTexture();
-    gl.bindTexture(gl.TEXTURE_2D, texture);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST);
-    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
-    return texture;
-  }
-
-  var currentGL, currentCanvas;
-
-  function generateGL() {
-    if (currentGL) {
-      return;
-    }
-
-    currentCanvas = document.createElement('canvas');
-    currentGL = currentCanvas.getContext('webgl', {
-      premultipliedalpha: false
-    });
-  }
-
-  var smaskVertexShaderCode = '\
-  attribute vec2 a_position;                                    \
-  attribute vec2 a_texCoord;                                    \
-                                                                \
-  uniform vec2 u_resolution;                                    \
-                                                                \
-  varying vec2 v_texCoord;                                      \
-                                                                \
-  void main() {                                                 \
-    vec2 clipSpace = (a_position / u_resolution) * 2.0 - 1.0;   \
-    gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);          \
-                                                                \
-    v_texCoord = a_texCoord;                                    \
-  }                                                             ';
-  var smaskFragmentShaderCode = '\
-  precision mediump float;                                      \
-                                                                \
-  uniform vec4 u_backdrop;                                      \
-  uniform int u_subtype;                                        \
-  uniform sampler2D u_image;                                    \
-  uniform sampler2D u_mask;                                     \
-                                                                \
-  varying vec2 v_texCoord;                                      \
-                                                                \
-  void main() {                                                 \
-    vec4 imageColor = texture2D(u_image, v_texCoord);           \
-    vec4 maskColor = texture2D(u_mask, v_texCoord);             \
-    if (u_backdrop.a > 0.0) {                                   \
-      maskColor.rgb = maskColor.rgb * maskColor.a +             \
-                      u_backdrop.rgb * (1.0 - maskColor.a);     \
-    }                                                           \
-    float lum;                                                  \
-    if (u_subtype == 0) {                                       \
-      lum = maskColor.a;                                        \
-    } else {                                                    \
-      lum = maskColor.r * 0.3 + maskColor.g * 0.59 +            \
-            maskColor.b * 0.11;                                 \
-    }                                                           \
-    imageColor.a *= lum;                                        \
-    imageColor.rgb *= imageColor.a;                             \
-    gl_FragColor = imageColor;                                  \
-  }                                                             ';
-  var smaskCache = null;
-
-  function initSmaskGL() {
-    var canvas, gl;
-    generateGL();
-    canvas = currentCanvas;
-    currentCanvas = null;
-    gl = currentGL;
-    currentGL = null;
-    var vertexShader = createVertexShader(gl, smaskVertexShaderCode);
-    var fragmentShader = createFragmentShader(gl, smaskFragmentShaderCode);
-    var program = createProgram(gl, [vertexShader, fragmentShader]);
-    gl.useProgram(program);
-    var cache = {};
-    cache.gl = gl;
-    cache.canvas = canvas;
-    cache.resolutionLocation = gl.getUniformLocation(program, 'u_resolution');
-    cache.positionLocation = gl.getAttribLocation(program, 'a_position');
-    cache.backdropLocation = gl.getUniformLocation(program, 'u_backdrop');
-    cache.subtypeLocation = gl.getUniformLocation(program, 'u_subtype');
-    var texCoordLocation = gl.getAttribLocation(program, 'a_texCoord');
-    var texLayerLocation = gl.getUniformLocation(program, 'u_image');
-    var texMaskLocation = gl.getUniformLocation(program, 'u_mask');
-    var texCoordBuffer = gl.createBuffer();
-    gl.bindBuffer(gl.ARRAY_BUFFER, texCoordBuffer);
-    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0]), gl.STATIC_DRAW);
-    gl.enableVertexAttribArray(texCoordLocation);
-    gl.vertexAttribPointer(texCoordLocation, 2, gl.FLOAT, false, 0, 0);
-    gl.uniform1i(texLayerLocation, 0);
-    gl.uniform1i(texMaskLocation, 1);
-    smaskCache = cache;
-  }
-
-  function composeSMask(layer, mask, properties) {
-    var width = layer.width,
-        height = layer.height;
-
-    if (!smaskCache) {
-      initSmaskGL();
-    }
-
-    var cache = smaskCache,
-        canvas = cache.canvas,
-        gl = cache.gl;
-    canvas.width = width;
-    canvas.height = height;
-    gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
-    gl.uniform2f(cache.resolutionLocation, width, height);
-
-    if (properties.backdrop) {
-      gl.uniform4f(cache.resolutionLocation, properties.backdrop[0], properties.backdrop[1], properties.backdrop[2], 1);
-    } else {
-      gl.uniform4f(cache.resolutionLocation, 0, 0, 0, 0);
-    }
-
-    gl.uniform1i(cache.subtypeLocation, properties.subtype === 'Luminosity' ? 1 : 0);
-    var texture = createTexture(gl, layer, gl.TEXTURE0);
-    var maskTexture = createTexture(gl, mask, gl.TEXTURE1);
-    var buffer = gl.createBuffer();
-    gl.bindBuffer(gl.ARRAY_BUFFER, buffer);
-    gl.bufferData(gl.ARRAY_BUFFER, new Float32Array([0, 0, width, 0, 0, height, 0, height, width, 0, width, height]), gl.STATIC_DRAW);
-    gl.enableVertexAttribArray(cache.positionLocation);
-    gl.vertexAttribPointer(cache.positionLocation, 2, gl.FLOAT, false, 0, 0);
-    gl.clearColor(0, 0, 0, 0);
-    gl.enable(gl.BLEND);
-    gl.blendFunc(gl.ONE, gl.ONE_MINUS_SRC_ALPHA);
-    gl.clear(gl.COLOR_BUFFER_BIT);
-    gl.drawArrays(gl.TRIANGLES, 0, 6);
-    gl.flush();
-    gl.deleteTexture(texture);
-    gl.deleteTexture(maskTexture);
-    gl.deleteBuffer(buffer);
-    return canvas;
-  }
-
-  var figuresVertexShaderCode = '\
-  attribute vec2 a_position;                                    \
-  attribute vec3 a_color;                                       \
-                                                                \
-  uniform vec2 u_resolution;                                    \
-  uniform vec2 u_scale;                                         \
-  uniform vec2 u_offset;                                        \
-                                                                \
-  varying vec4 v_color;                                         \
-                                                                \
-  void main() {                                                 \
-    vec2 position = (a_position + u_offset) * u_scale;          \
-    vec2 clipSpace = (position / u_resolution) * 2.0 - 1.0;     \
-    gl_Position = vec4(clipSpace * vec2(1, -1), 0, 1);          \
-                                                                \
-    v_color = vec4(a_color / 255.0, 1.0);                       \
-  }                                                             ';
-  var figuresFragmentShaderCode = '\
-  precision mediump float;                                      \
-                                                                \
-  varying vec4 v_color;                                         \
-                                                                \
-  void main() {                                                 \
-    gl_FragColor = v_color;                                     \
-  }                                                             ';
-  var figuresCache = null;
-
-  function initFiguresGL() {
-    var canvas, gl;
-    generateGL();
-    canvas = currentCanvas;
-    currentCanvas = null;
-    gl = currentGL;
-    currentGL = null;
-    var vertexShader = createVertexShader(gl, figuresVertexShaderCode);
-    var fragmentShader = createFragmentShader(gl, figuresFragmentShaderCode);
-    var program = createProgram(gl, [vertexShader, fragmentShader]);
-    gl.useProgram(program);
-    var cache = {};
-    cache.gl = gl;
-    cache.canvas = canvas;
-    cache.resolutionLocation = gl.getUniformLocation(program, 'u_resolution');
-    cache.scaleLocation = gl.getUniformLocation(program, 'u_scale');
-    cache.offsetLocation = gl.getUniformLocation(program, 'u_offset');
-    cache.positionLocation = gl.getAttribLocation(program, 'a_position');
-    cache.colorLocation = gl.getAttribLocation(program, 'a_color');
-    figuresCache = cache;
-  }
-
-  function drawFigures(width, height, backgroundColor, figures, context) {
-    if (!figuresCache) {
-      initFiguresGL();
-    }
-
-    var cache = figuresCache,
-        canvas = cache.canvas,
-        gl = cache.gl;
-    canvas.width = width;
-    canvas.height = height;
-    gl.viewport(0, 0, gl.drawingBufferWidth, gl.drawingBufferHeight);
-    gl.uniform2f(cache.resolutionLocation, width, height);
-    var count = 0;
-    var i, ii, rows;
-
-    for (i = 0, ii = figures.length; i < ii; i++) {
-      switch (figures[i].type) {
-        case 'lattice':
-          rows = figures[i].coords.length / figures[i].verticesPerRow | 0;
-          count += (rows - 1) * (figures[i].verticesPerRow - 1) * 6;
-          break;
-
-        case 'triangles':
-          count += figures[i].coords.length;
-          break;
-      }
-    }
-
-    var coords = new Float32Array(count * 2);
-    var colors = new Uint8Array(count * 3);
-    var coordsMap = context.coords,
-        colorsMap = context.colors;
-    var pIndex = 0,
-        cIndex = 0;
-
-    for (i = 0, ii = figures.length; i < ii; i++) {
-      var figure = figures[i],
-          ps = figure.coords,
-          cs = figure.colors;
-
-      switch (figure.type) {
-        case 'lattice':
-          var cols = figure.verticesPerRow;
-          rows = ps.length / cols | 0;
-
-          for (var row = 1; row < rows; row++) {
-            var offset = row * cols + 1;
-
-            for (var col = 1; col < cols; col++, offset++) {
-              coords[pIndex] = coordsMap[ps[offset - cols - 1]];
-              coords[pIndex + 1] = coordsMap[ps[offset - cols - 1] + 1];
-              coords[pIndex + 2] = coordsMap[ps[offset - cols]];
-              coords[pIndex + 3] = coordsMap[ps[offset - cols] + 1];
-              coords[pIndex + 4] = coordsMap[ps[offset - 1]];
-              coords[pIndex + 5] = coordsMap[ps[offset - 1] + 1];
-              colors[cIndex] = colorsMap[cs[offset - cols - 1]];
-              colors[cIndex + 1] = colorsMap[cs[offset - cols - 1] + 1];
-              colors[cIndex + 2] = colorsMap[cs[offset - cols - 1] + 2];
-              colors[cIndex + 3] = colorsMap[cs[offset - cols]];
-              colors[cIndex + 4] = colorsMap[cs[offset - cols] + 1];
-              colors[cIndex + 5] = colorsMap[cs[offset - cols] + 2];
-              colors[cIndex + 6] = colorsMap[cs[offset - 1]];
-              colors[cIndex + 7] = colorsMap[cs[offset - 1] + 1];
-              colors[cIndex + 8] = colorsMap[cs[offset - 1] + 2];
-              coords[pIndex + 6] = coords[pIndex + 2];
-              coords[pIndex + 7] = coords[pIndex + 3];
-              coords[pIndex + 8] = coords[pIndex + 4];
-              coords[pIndex + 9] = coords[pIndex + 5];
-              coords[pIndex + 10] = coordsMap[ps[offset]];
-              coords[pIndex + 11] = coordsMap[ps[offset] + 1];
-              colors[cIndex + 9] = colors[cIndex + 3];
-              colors[cIndex + 10] = colors[cIndex + 4];
-              colors[cIndex + 11] = colors[cIndex + 5];
-              colors[cIndex + 12] = colors[cIndex + 6];
-              colors[cIndex + 13] = colors[cIndex + 7];
-              colors[cIndex + 14] = colors[cIndex + 8];
-              colors[cIndex + 15] = colorsMap[cs[offset]];
-              colors[cIndex + 16] = colorsMap[cs[offset] + 1];
-              colors[cIndex + 17] = colorsMap[cs[offset] + 2];
-              pIndex += 12;
-              cIndex += 18;
-            }
-          }
-
-          break;
-
-        case 'triangles':
-          for (var j = 0, jj = ps.length; j < jj; j++) {
-            coords[pIndex] = coordsMap[ps[j]];
-            coords[pIndex + 1] = coordsMap[ps[j] + 1];
-            colors[cIndex] = colorsMap[cs[j]];
-            colors[cIndex + 1] = colorsMap[cs[j] + 1];
-            colors[cIndex + 2] = colorsMap[cs[j] + 2];
-            pIndex += 2;
-            cIndex += 3;
-          }
-
-          break;
-      }
-    }
-
-    if (backgroundColor) {
-      gl.clearColor(backgroundColor[0] / 255, backgroundColor[1] / 255, backgroundColor[2] / 255, 1.0);
-    } else {
-      gl.clearColor(0, 0, 0, 0);
-    }
-
-    gl.clear(gl.COLOR_BUFFER_BIT);
-    var coordsBuffer = gl.createBuffer();
-    gl.bindBuffer(gl.ARRAY_BUFFER, coordsBuffer);
-    gl.bufferData(gl.ARRAY_BUFFER, coords, gl.STATIC_DRAW);
-    gl.enableVertexAttribArray(cache.positionLocation);
-    gl.vertexAttribPointer(cache.positionLocation, 2, gl.FLOAT, false, 0, 0);
-    var colorsBuffer = gl.createBuffer();
-    gl.bindBuffer(gl.ARRAY_BUFFER, colorsBuffer);
-    gl.bufferData(gl.ARRAY_BUFFER, colors, gl.STATIC_DRAW);
-    gl.enableVertexAttribArray(cache.colorLocation);
-    gl.vertexAttribPointer(cache.colorLocation, 3, gl.UNSIGNED_BYTE, false, 0, 0);
-    gl.uniform2f(cache.scaleLocation, context.scaleX, context.scaleY);
-    gl.uniform2f(cache.offsetLocation, context.offsetX, context.offsetY);
-    gl.drawArrays(gl.TRIANGLES, 0, count);
-    gl.flush();
-    gl.deleteBuffer(coordsBuffer);
-    gl.deleteBuffer(colorsBuffer);
-    return canvas;
-  }
-
-  return {
-    tryInitGL: function tryInitGL() {
-      try {
-        generateGL();
-        return !!currentGL;
-      } catch (ex) {}
-
-      return false;
-    },
-    composeSMask: composeSMask,
-    drawFigures: drawFigures,
-    cleanup: function cleanup() {
-      if (smaskCache && smaskCache.canvas) {
-        smaskCache.canvas.width = 0;
-        smaskCache.canvas.height = 0;
-      }
-
-      if (figuresCache && figuresCache.canvas) {
-        figuresCache.canvas.width = 0;
-        figuresCache.canvas.height = 0;
-      }
-
-      smaskCache = null;
-      figuresCache = null;
-    }
-  };
-}();
-
-/***/ }),
-/* 162 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.renderTextLayer = void 0;
-
-var _util = __w_pdfjs_require__(1);
-
-var _global_scope = _interopRequireDefault(__w_pdfjs_require__(3));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
-var renderTextLayer = function renderTextLayerClosure() {
-  var MAX_TEXT_DIVS_TO_RENDER = 100000;
-  var NonWhitespaceRegexp = /\S/;
-
-  function isAllWhitespace(str) {
-    return !NonWhitespaceRegexp.test(str);
-  }
-
-  var styleBuf = ['left: ', 0, 'px; top: ', 0, 'px; font-size: ', 0, 'px; font-family: ', '', ';'];
-
-  function appendText(task, geom, styles) {
-    var textDiv = document.createElement('span');
-    var textDivProperties = {
-      style: null,
-      angle: 0,
-      canvasWidth: 0,
-      isWhitespace: false,
-      originalTransform: null,
-      paddingBottom: 0,
-      paddingLeft: 0,
-      paddingRight: 0,
-      paddingTop: 0,
-      scale: 1
-    };
-
-    task._textDivs.push(textDiv);
-
-    if (isAllWhitespace(geom.str)) {
-      textDivProperties.isWhitespace = true;
-
-      task._textDivProperties.set(textDiv, textDivProperties);
-
-      return;
-    }
-
-    var tx = _util.Util.transform(task._viewport.transform, geom.transform);
-
-    var angle = Math.atan2(tx[1], tx[0]);
-    var style = styles[geom.fontName];
-
-    if (style.vertical) {
-      angle += Math.PI / 2;
-    }
-
-    var fontHeight = Math.sqrt(tx[2] * tx[2] + tx[3] * tx[3]);
-    var fontAscent = fontHeight;
-
-    if (style.ascent) {
-      fontAscent = style.ascent * fontAscent;
-    } else if (style.descent) {
-      fontAscent = (1 + style.descent) * fontAscent;
-    }
-
-    var left;
-    var top;
-
-    if (angle === 0) {
-      left = tx[4];
-      top = tx[5] - fontAscent;
-    } else {
-      left = tx[4] + fontAscent * Math.sin(angle);
-      top = tx[5] - fontAscent * Math.cos(angle);
-    }
-
-    styleBuf[1] = left;
-    styleBuf[3] = top;
-    styleBuf[5] = fontHeight;
-    styleBuf[7] = style.fontFamily;
-    textDivProperties.style = styleBuf.join('');
-    textDiv.setAttribute('style', textDivProperties.style);
-    textDiv.textContent = geom.str;
-
-    if (task._fontInspectorEnabled) {
-      textDiv.dataset.fontName = geom.fontName;
-    }
-
-    if (angle !== 0) {
-      textDivProperties.angle = angle * (180 / Math.PI);
-    }
-
-    if (geom.str.length > 1) {
-      if (style.vertical) {
-        textDivProperties.canvasWidth = geom.height * task._viewport.scale;
-      } else {
-        textDivProperties.canvasWidth = geom.width * task._viewport.scale;
-      }
-    }
-
-    task._textDivProperties.set(textDiv, textDivProperties);
-
-    if (task._textContentStream) {
-      task._layoutText(textDiv);
-    }
-
-    if (task._enhanceTextSelection) {
-      var angleCos = 1,
-          angleSin = 0;
-
-      if (angle !== 0) {
-        angleCos = Math.cos(angle);
-        angleSin = Math.sin(angle);
-      }
-
-      var divWidth = (style.vertical ? geom.height : geom.width) * task._viewport.scale;
-      var divHeight = fontHeight;
-      var m, b;
-
-      if (angle !== 0) {
-        m = [angleCos, angleSin, -angleSin, angleCos, left, top];
-        b = _util.Util.getAxialAlignedBoundingBox([0, 0, divWidth, divHeight], m);
-      } else {
-        b = [left, top, left + divWidth, top + divHeight];
-      }
-
-      task._bounds.push({
-        left: b[0],
-        top: b[1],
-        right: b[2],
-        bottom: b[3],
-        div: textDiv,
-        size: [divWidth, divHeight],
-        m: m
-      });
-    }
-  }
-
-  function render(task) {
-    if (task._canceled) {
-      return;
-    }
-
-    var textDivs = task._textDivs;
-    var capability = task._capability;
-    var textDivsLength = textDivs.length;
-
-    if (textDivsLength > MAX_TEXT_DIVS_TO_RENDER) {
-      task._renderingDone = true;
-      capability.resolve();
-      return;
-    }
-
-    if (!task._textContentStream) {
-      for (var i = 0; i < textDivsLength; i++) {
-        task._layoutText(textDivs[i]);
-      }
-    }
-
-    task._renderingDone = true;
-    capability.resolve();
-  }
-
-  function expand(task) {
-    var bounds = task._bounds;
-    var viewport = task._viewport;
-    var expanded = expandBounds(viewport.width, viewport.height, bounds);
-
-    for (var i = 0; i < expanded.length; i++) {
-      var div = bounds[i].div;
-
-      var divProperties = task._textDivProperties.get(div);
-
-      if (divProperties.angle === 0) {
-        divProperties.paddingLeft = bounds[i].left - expanded[i].left;
-        divProperties.paddingTop = bounds[i].top - expanded[i].top;
-        divProperties.paddingRight = expanded[i].right - bounds[i].right;
-        divProperties.paddingBottom = expanded[i].bottom - bounds[i].bottom;
-
-        task._textDivProperties.set(div, divProperties);
-
-        continue;
-      }
-
-      var e = expanded[i],
-          b = bounds[i];
-      var m = b.m,
-          c = m[0],
-          s = m[1];
-      var points = [[0, 0], [0, b.size[1]], [b.size[0], 0], b.size];
-      var ts = new Float64Array(64);
-      points.forEach(function (p, i) {
-        var t = _util.Util.applyTransform(p, m);
-
-        ts[i + 0] = c && (e.left - t[0]) / c;
-        ts[i + 4] = s && (e.top - t[1]) / s;
-        ts[i + 8] = c && (e.right - t[0]) / c;
-        ts[i + 12] = s && (e.bottom - t[1]) / s;
-        ts[i + 16] = s && (e.left - t[0]) / -s;
-        ts[i + 20] = c && (e.top - t[1]) / c;
-        ts[i + 24] = s && (e.right - t[0]) / -s;
-        ts[i + 28] = c && (e.bottom - t[1]) / c;
-        ts[i + 32] = c && (e.left - t[0]) / -c;
-        ts[i + 36] = s && (e.top - t[1]) / -s;
-        ts[i + 40] = c && (e.right - t[0]) / -c;
-        ts[i + 44] = s && (e.bottom - t[1]) / -s;
-        ts[i + 48] = s && (e.left - t[0]) / s;
-        ts[i + 52] = c && (e.top - t[1]) / -c;
-        ts[i + 56] = s && (e.right - t[0]) / s;
-        ts[i + 60] = c && (e.bottom - t[1]) / -c;
-      });
-
-      var findPositiveMin = function findPositiveMin(ts, offset, count) {
-        var result = 0;
-
-        for (var i = 0; i < count; i++) {
-          var t = ts[offset++];
-
-          if (t > 0) {
-            result = result ? Math.min(t, result) : t;
-          }
-        }
-
-        return result;
-      };
-
-      var boxScale = 1 + Math.min(Math.abs(c), Math.abs(s));
-      divProperties.paddingLeft = findPositiveMin(ts, 32, 16) / boxScale;
-      divProperties.paddingTop = findPositiveMin(ts, 48, 16) / boxScale;
-      divProperties.paddingRight = findPositiveMin(ts, 0, 16) / boxScale;
-      divProperties.paddingBottom = findPositiveMin(ts, 16, 16) / boxScale;
-
-      task._textDivProperties.set(div, divProperties);
-    }
-  }
-
-  function expandBounds(width, height, boxes) {
-    var bounds = boxes.map(function (box, i) {
-      return {
-        x1: box.left,
-        y1: box.top,
-        x2: box.right,
-        y2: box.bottom,
-        index: i,
-        x1New: undefined,
-        x2New: undefined
-      };
-    });
-    expandBoundsLTR(width, bounds);
-    var expanded = new Array(boxes.length);
-    bounds.forEach(function (b) {
-      var i = b.index;
-      expanded[i] = {
-        left: b.x1New,
-        top: 0,
-        right: b.x2New,
-        bottom: 0
-      };
-    });
-    boxes.map(function (box, i) {
-      var e = expanded[i],
-          b = bounds[i];
-      b.x1 = box.top;
-      b.y1 = width - e.right;
-      b.x2 = box.bottom;
-      b.y2 = width - e.left;
-      b.index = i;
-      b.x1New = undefined;
-      b.x2New = undefined;
-    });
-    expandBoundsLTR(height, bounds);
-    bounds.forEach(function (b) {
-      var i = b.index;
-      expanded[i].top = b.x1New;
-      expanded[i].bottom = b.x2New;
-    });
-    return expanded;
-  }
-
-  function expandBoundsLTR(width, bounds) {
-    bounds.sort(function (a, b) {
-      return a.x1 - b.x1 || a.index - b.index;
-    });
-    var fakeBoundary = {
-      x1: -Infinity,
-      y1: -Infinity,
-      x2: 0,
-      y2: Infinity,
-      index: -1,
-      x1New: 0,
-      x2New: 0
-    };
-    var horizon = [{
-      start: -Infinity,
-      end: Infinity,
-      boundary: fakeBoundary
-    }];
-    bounds.forEach(function (boundary) {
-      var i = 0;
-
-      while (i < horizon.length && horizon[i].end <= boundary.y1) {
-        i++;
-      }
-
-      var j = horizon.length - 1;
-
-      while (j >= 0 && horizon[j].start >= boundary.y2) {
-        j--;
-      }
-
-      var horizonPart, affectedBoundary;
-      var q,
-          k,
-          maxXNew = -Infinity;
-
-      for (q = i; q <= j; q++) {
-        horizonPart = horizon[q];
-        affectedBoundary = horizonPart.boundary;
-        var xNew;
-
-        if (affectedBoundary.x2 > boundary.x1) {
-          xNew = affectedBoundary.index > boundary.index ? affectedBoundary.x1New : boundary.x1;
-        } else if (affectedBoundary.x2New === undefined) {
-          xNew = (affectedBoundary.x2 + boundary.x1) / 2;
-        } else {
-          xNew = affectedBoundary.x2New;
-        }
-
-        if (xNew > maxXNew) {
-          maxXNew = xNew;
-        }
-      }
-
-      boundary.x1New = maxXNew;
-
-      for (q = i; q <= j; q++) {
-        horizonPart = horizon[q];
-        affectedBoundary = horizonPart.boundary;
-
-        if (affectedBoundary.x2New === undefined) {
-          if (affectedBoundary.x2 > boundary.x1) {
-            if (affectedBoundary.index > boundary.index) {
-              affectedBoundary.x2New = affectedBoundary.x2;
-            }
-          } else {
-            affectedBoundary.x2New = maxXNew;
-          }
-        } else if (affectedBoundary.x2New > maxXNew) {
-          affectedBoundary.x2New = Math.max(maxXNew, affectedBoundary.x2);
-        }
-      }
-
-      var changedHorizon = [],
-          lastBoundary = null;
-
-      for (q = i; q <= j; q++) {
-        horizonPart = horizon[q];
-        affectedBoundary = horizonPart.boundary;
-        var useBoundary = affectedBoundary.x2 > boundary.x2 ? affectedBoundary : boundary;
-
-        if (lastBoundary === useBoundary) {
-          changedHorizon[changedHorizon.length - 1].end = horizonPart.end;
-        } else {
-          changedHorizon.push({
-            start: horizonPart.start,
-            end: horizonPart.end,
-            boundary: useBoundary
-          });
-          lastBoundary = useBoundary;
-        }
-      }
-
-      if (horizon[i].start < boundary.y1) {
-        changedHorizon[0].start = boundary.y1;
-        changedHorizon.unshift({
-          start: horizon[i].start,
-          end: boundary.y1,
-          boundary: horizon[i].boundary
-        });
-      }
-
-      if (boundary.y2 < horizon[j].end) {
-        changedHorizon[changedHorizon.length - 1].end = boundary.y2;
-        changedHorizon.push({
-          start: boundary.y2,
-          end: horizon[j].end,
-          boundary: horizon[j].boundary
-        });
-      }
-
-      for (q = i; q <= j; q++) {
-        horizonPart = horizon[q];
-        affectedBoundary = horizonPart.boundary;
-
-        if (affectedBoundary.x2New !== undefined) {
-          continue;
-        }
-
-        var used = false;
-
-        for (k = i - 1; !used && k >= 0 && horizon[k].start >= affectedBoundary.y1; k--) {
-          used = horizon[k].boundary === affectedBoundary;
-        }
-
-        for (k = j + 1; !used && k < horizon.length && horizon[k].end <= affectedBoundary.y2; k++) {
-          used = horizon[k].boundary === affectedBoundary;
-        }
-
-        for (k = 0; !used && k < changedHorizon.length; k++) {
-          used = changedHorizon[k].boundary === affectedBoundary;
-        }
-
-        if (!used) {
-          affectedBoundary.x2New = maxXNew;
-        }
-      }
-
-      Array.prototype.splice.apply(horizon, [i, j - i + 1].concat(changedHorizon));
-    });
-    horizon.forEach(function (horizonPart) {
-      var affectedBoundary = horizonPart.boundary;
-
-      if (affectedBoundary.x2New === undefined) {
-        affectedBoundary.x2New = Math.max(width, affectedBoundary.x2);
-      }
-    });
-  }
-
-  function TextLayerRenderTask(_ref) {
-    var _this = this;
-
-    var textContent = _ref.textContent,
-        textContentStream = _ref.textContentStream,
-        container = _ref.container,
-        viewport = _ref.viewport,
-        textDivs = _ref.textDivs,
-        textContentItemsStr = _ref.textContentItemsStr,
-        enhanceTextSelection = _ref.enhanceTextSelection;
-    this._textContent = textContent;
-    this._textContentStream = textContentStream;
-    this._container = container;
-    this._viewport = viewport;
-    this._textDivs = textDivs || [];
-    this._textContentItemsStr = textContentItemsStr || [];
-    this._enhanceTextSelection = !!enhanceTextSelection;
-    this._fontInspectorEnabled = !!(_global_scope["default"].FontInspector && _global_scope["default"].FontInspector.enabled);
-    this._reader = null;
-    this._layoutTextLastFontSize = null;
-    this._layoutTextLastFontFamily = null;
-    this._layoutTextCtx = null;
-    this._textDivProperties = new WeakMap();
-    this._renderingDone = false;
-    this._canceled = false;
-    this._capability = (0, _util.createPromiseCapability)();
-    this._renderTimer = null;
-    this._bounds = [];
-
-    this._capability.promise["finally"](function () {
-      if (_this._layoutTextCtx) {
-        _this._layoutTextCtx.canvas.width = 0;
-        _this._layoutTextCtx.canvas.height = 0;
-        _this._layoutTextCtx = null;
-      }
-    });
-  }
-
-  TextLayerRenderTask.prototype = {
-    get promise() {
-      return this._capability.promise;
-    },
-
-    cancel: function TextLayer_cancel() {
-      this._canceled = true;
-
-      if (this._reader) {
-        this._reader.cancel(new _util.AbortException('TextLayer task cancelled.'));
-
-        this._reader = null;
-      }
-
-      if (this._renderTimer !== null) {
-        clearTimeout(this._renderTimer);
-        this._renderTimer = null;
-      }
-
-      this._capability.reject(new Error('TextLayer task cancelled.'));
-    },
-    _processItems: function _processItems(items, styleCache) {
-      for (var i = 0, len = items.length; i < len; i++) {
-        this._textContentItemsStr.push(items[i].str);
-
-        appendText(this, items[i], styleCache);
-      }
-    },
-    _layoutText: function _layoutText(textDiv) {
-      var textLayerFrag = this._container;
-
-      var textDivProperties = this._textDivProperties.get(textDiv);
-
-      if (textDivProperties.isWhitespace) {
-        return;
-      }
-
-      var fontSize = textDiv.style.fontSize;
-      var fontFamily = textDiv.style.fontFamily;
-
-      if (fontSize !== this._layoutTextLastFontSize || fontFamily !== this._layoutTextLastFontFamily) {
-        this._layoutTextCtx.font = fontSize + ' ' + fontFamily;
-        this._layoutTextLastFontSize = fontSize;
-        this._layoutTextLastFontFamily = fontFamily;
-      }
-
-      var width = this._layoutTextCtx.measureText(textDiv.textContent).width;
-
-      var transform = '';
-
-      if (textDivProperties.canvasWidth !== 0 && width > 0) {
-        textDivProperties.scale = textDivProperties.canvasWidth / width;
-        transform = "scaleX(".concat(textDivProperties.scale, ")");
-      }
-
-      if (textDivProperties.angle !== 0) {
-        transform = "rotate(".concat(textDivProperties.angle, "deg) ").concat(transform);
-      }
-
-      if (transform.length > 0) {
-        textDivProperties.originalTransform = transform;
-        textDiv.style.transform = transform;
-      }
-
-      this._textDivProperties.set(textDiv, textDivProperties);
-
-      textLayerFrag.appendChild(textDiv);
-    },
-    _render: function TextLayer_render(timeout) {
-      var _this2 = this;
-
-      var capability = (0, _util.createPromiseCapability)();
-      var styleCache = Object.create(null);
-      var canvas = document.createElement('canvas');
-      canvas.mozOpaque = true;
-      this._layoutTextCtx = canvas.getContext('2d', {
-        alpha: false
-      });
-
-      if (this._textContent) {
-        var textItems = this._textContent.items;
-        var textStyles = this._textContent.styles;
-
-        this._processItems(textItems, textStyles);
-
-        capability.resolve();
-      } else if (this._textContentStream) {
-        var pump = function pump() {
-          _this2._reader.read().then(function (_ref2) {
-            var value = _ref2.value,
-                done = _ref2.done;
-
-            if (done) {
-              capability.resolve();
-              return;
-            }
-
-            Object.assign(styleCache, value.styles);
-
-            _this2._processItems(value.items, styleCache);
-
-            pump();
-          }, capability.reject);
-        };
-
-        this._reader = this._textContentStream.getReader();
-        pump();
-      } else {
-        throw new Error('Neither "textContent" nor "textContentStream"' + ' parameters specified.');
-      }
-
-      capability.promise.then(function () {
-        styleCache = null;
-
-        if (!timeout) {
-          render(_this2);
-        } else {
-          _this2._renderTimer = setTimeout(function () {
-            render(_this2);
-            _this2._renderTimer = null;
-          }, timeout);
-        }
-      }, this._capability.reject);
-    },
-    expandTextDivs: function TextLayer_expandTextDivs(expandDivs) {
-      if (!this._enhanceTextSelection || !this._renderingDone) {
-        return;
-      }
-
-      if (this._bounds !== null) {
-        expand(this);
-        this._bounds = null;
-      }
-
-      for (var i = 0, ii = this._textDivs.length; i < ii; i++) {
-        var div = this._textDivs[i];
-
-        var divProperties = this._textDivProperties.get(div);
-
-        if (divProperties.isWhitespace) {
-          continue;
-        }
-
-        if (expandDivs) {
-          var transform = '',
-              padding = '';
-
-          if (divProperties.scale !== 1) {
-            transform = 'scaleX(' + divProperties.scale + ')';
-          }
-
-          if (divProperties.angle !== 0) {
-            transform = 'rotate(' + divProperties.angle + 'deg) ' + transform;
-          }
-
-          if (divProperties.paddingLeft !== 0) {
-            padding += ' padding-left: ' + divProperties.paddingLeft / divProperties.scale + 'px;';
-            transform += ' translateX(' + -divProperties.paddingLeft / divProperties.scale + 'px)';
-          }
-
-          if (divProperties.paddingTop !== 0) {
-            padding += ' padding-top: ' + divProperties.paddingTop + 'px;';
-            transform += ' translateY(' + -divProperties.paddingTop + 'px)';
-          }
-
-          if (divProperties.paddingRight !== 0) {
-            padding += ' padding-right: ' + divProperties.paddingRight / divProperties.scale + 'px;';
-          }
-
-          if (divProperties.paddingBottom !== 0) {
-            padding += ' padding-bottom: ' + divProperties.paddingBottom + 'px;';
-          }
-
-          if (padding !== '') {
-            div.setAttribute('style', divProperties.style + padding);
-          }
-
-          if (transform !== '') {
-            div.style.transform = transform;
-          }
-        } else {
-          div.style.padding = 0;
-          div.style.transform = divProperties.originalTransform || '';
-        }
-      }
-    }
-  };
-
-  function renderTextLayer(renderParameters) {
-    var task = new TextLayerRenderTask({
-      textContent: renderParameters.textContent,
-      textContentStream: renderParameters.textContentStream,
-      container: renderParameters.container,
-      viewport: renderParameters.viewport,
-      textDivs: renderParameters.textDivs,
-      textContentItemsStr: renderParameters.textContentItemsStr,
-      enhanceTextSelection: renderParameters.enhanceTextSelection
-    });
-
-    task._render(renderParameters.timeout);
-
-    return task;
-  }
-
-  return renderTextLayer;
-}();
-
-exports.renderTextLayer = renderTextLayer;
-
-/***/ }),
-/* 163 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.AnnotationLayer = void 0;
-
-var _display_utils = __w_pdfjs_require__(151);
-
-var _util = __w_pdfjs_require__(1);
-
-function _get(target, property, receiver) { if (typeof Reflect !== "undefined" && Reflect.get) { _get = Reflect.get; } else { _get = function _get(target, property, receiver) { var base = _superPropBase(target, property); if (!base) return; var desc = Object.getOwnPropertyDescriptor(base, property); if (desc.get) { return desc.get.call(receiver); } return desc.value; }; } return _get(target, property, receiver || target); }
-
-function _superPropBase(object, property) { while (!Object.prototype.hasOwnProperty.call(object, property)) { object = _getPrototypeOf(object); if (object === null) break; } return object; }
-
-function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
-
-function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
-
-function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
-
-function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
-
-function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
-
-function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-var AnnotationElementFactory =
-/*#__PURE__*/
-function () {
-  function AnnotationElementFactory() {
-    _classCallCheck(this, AnnotationElementFactory);
-  }
-
-  _createClass(AnnotationElementFactory, null, [{
-    key: "create",
-    value: function create(parameters) {
-      var subtype = parameters.data.annotationType;
-
-      switch (subtype) {
-        case _util.AnnotationType.LINK:
-          return new LinkAnnotationElement(parameters);
-
-        case _util.AnnotationType.TEXT:
-          return new TextAnnotationElement(parameters);
-
-        case _util.AnnotationType.WIDGET:
-          var fieldType = parameters.data.fieldType;
-
-          switch (fieldType) {
-            case 'Tx':
-              return new TextWidgetAnnotationElement(parameters);
-
-            case 'Btn':
-              if (parameters.data.radioButton) {
-                return new RadioButtonWidgetAnnotationElement(parameters);
-              } else if (parameters.data.checkBox) {
-                return new CheckboxWidgetAnnotationElement(parameters);
-              }
-
-              return new PushButtonWidgetAnnotationElement(parameters);
-
-            case 'Ch':
-              return new ChoiceWidgetAnnotationElement(parameters);
-          }
-
-          return new WidgetAnnotationElement(parameters);
-
-        case _util.AnnotationType.POPUP:
-          return new PopupAnnotationElement(parameters);
-
-        case _util.AnnotationType.FREETEXT:
-          return new FreeTextAnnotationElement(parameters);
-
-        case _util.AnnotationType.LINE:
-          return new LineAnnotationElement(parameters);
-
-        case _util.AnnotationType.SQUARE:
-          return new SquareAnnotationElement(parameters);
-
-        case _util.AnnotationType.CIRCLE:
-          return new CircleAnnotationElement(parameters);
-
-        case _util.AnnotationType.POLYLINE:
-          return new PolylineAnnotationElement(parameters);
-
-        case _util.AnnotationType.CARET:
-          return new CaretAnnotationElement(parameters);
-
-        case _util.AnnotationType.INK:
-          return new InkAnnotationElement(parameters);
-
-        case _util.AnnotationType.POLYGON:
-          return new PolygonAnnotationElement(parameters);
-
-        case _util.AnnotationType.HIGHLIGHT:
-          return new HighlightAnnotationElement(parameters);
-
-        case _util.AnnotationType.UNDERLINE:
-          return new UnderlineAnnotationElement(parameters);
-
-        case _util.AnnotationType.SQUIGGLY:
-          return new SquigglyAnnotationElement(parameters);
-
-        case _util.AnnotationType.STRIKEOUT:
-          return new StrikeOutAnnotationElement(parameters);
-
-        case _util.AnnotationType.STAMP:
-          return new StampAnnotationElement(parameters);
-
-        case _util.AnnotationType.FILEATTACHMENT:
-          return new FileAttachmentAnnotationElement(parameters);
-
-        default:
-          return new AnnotationElement(parameters);
-      }
-    }
-  }]);
-
-  return AnnotationElementFactory;
-}();
-
-var AnnotationElement =
-/*#__PURE__*/
-function () {
-  function AnnotationElement(parameters) {
-    var isRenderable = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
-    var ignoreBorder = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
-
-    _classCallCheck(this, AnnotationElement);
-
-    this.isRenderable = isRenderable;
-    this.data = parameters.data;
-    this.layer = parameters.layer;
-    this.page = parameters.page;
-    this.viewport = parameters.viewport;
-    this.linkService = parameters.linkService;
-    this.downloadManager = parameters.downloadManager;
-    this.imageResourcesPath = parameters.imageResourcesPath;
-    this.renderInteractiveForms = parameters.renderInteractiveForms;
-    this.svgFactory = parameters.svgFactory;
-
-    if (isRenderable) {
-      this.container = this._createContainer(ignoreBorder);
-    }
-  }
-
-  _createClass(AnnotationElement, [{
-    key: "_createContainer",
-    value: function _createContainer() {
-      var ignoreBorder = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-      var data = this.data,
-          page = this.page,
-          viewport = this.viewport;
-      var container = document.createElement('section');
-      var width = data.rect[2] - data.rect[0];
-      var height = data.rect[3] - data.rect[1];
-      container.setAttribute('data-annotation-id', data.id);
-
-      var rect = _util.Util.normalizeRect([data.rect[0], page.view[3] - data.rect[1] + page.view[1], data.rect[2], page.view[3] - data.rect[3] + page.view[1]]);
-
-      container.style.transform = 'matrix(' + viewport.transform.join(',') + ')';
-      container.style.transformOrigin = -rect[0] + 'px ' + -rect[1] + 'px';
-
-      if (!ignoreBorder && data.borderStyle.width > 0) {
-        container.style.borderWidth = data.borderStyle.width + 'px';
-
-        if (data.borderStyle.style !== _util.AnnotationBorderStyleType.UNDERLINE) {
-          width = width - 2 * data.borderStyle.width;
-          height = height - 2 * data.borderStyle.width;
-        }
-
-        var horizontalRadius = data.borderStyle.horizontalCornerRadius;
-        var verticalRadius = data.borderStyle.verticalCornerRadius;
-
-        if (horizontalRadius > 0 || verticalRadius > 0) {
-          var radius = horizontalRadius + 'px / ' + verticalRadius + 'px';
-          container.style.borderRadius = radius;
-        }
-
-        switch (data.borderStyle.style) {
-          case _util.AnnotationBorderStyleType.SOLID:
-            container.style.borderStyle = 'solid';
-            break;
-
-          case _util.AnnotationBorderStyleType.DASHED:
-            container.style.borderStyle = 'dashed';
-            break;
-
-          case _util.AnnotationBorderStyleType.BEVELED:
-            (0, _util.warn)('Unimplemented border style: beveled');
-            break;
-
-          case _util.AnnotationBorderStyleType.INSET:
-            (0, _util.warn)('Unimplemented border style: inset');
-            break;
-
-          case _util.AnnotationBorderStyleType.UNDERLINE:
-            container.style.borderBottomStyle = 'solid';
-            break;
-
-          default:
-            break;
-        }
-
-        if (data.color) {
-          container.style.borderColor = _util.Util.makeCssRgb(data.color[0] | 0, data.color[1] | 0, data.color[2] | 0);
-        } else {
-          container.style.borderWidth = 0;
-        }
-      }
-
-      container.style.left = rect[0] + 'px';
-      container.style.top = rect[1] + 'px';
-      container.style.width = width + 'px';
-      container.style.height = height + 'px';
-      return container;
-    }
-  }, {
-    key: "_createPopup",
-    value: function _createPopup(container, trigger, data) {
-      if (!trigger) {
-        trigger = document.createElement('div');
-        trigger.style.height = container.style.height;
-        trigger.style.width = container.style.width;
-        container.appendChild(trigger);
-      }
-
-      var popupElement = new PopupElement({
-        container: container,
-        trigger: trigger,
-        color: data.color,
-        title: data.title,
-        modificationDate: data.modificationDate,
-        contents: data.contents,
-        hideWrapper: true
-      });
-      var popup = popupElement.render();
-      popup.style.left = container.style.width;
-      container.appendChild(popup);
-    }
-  }, {
-    key: "render",
-    value: function render() {
-      (0, _util.unreachable)('Abstract method `AnnotationElement.render` called');
-    }
-  }]);
-
-  return AnnotationElement;
-}();
-
-var LinkAnnotationElement =
-/*#__PURE__*/
-function (_AnnotationElement) {
-  _inherits(LinkAnnotationElement, _AnnotationElement);
-
-  function LinkAnnotationElement(parameters) {
-    _classCallCheck(this, LinkAnnotationElement);
-
-    var isRenderable = !!(parameters.data.url || parameters.data.dest || parameters.data.action);
-    return _possibleConstructorReturn(this, _getPrototypeOf(LinkAnnotationElement).call(this, parameters, isRenderable));
-  }
-
-  _createClass(LinkAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = 'linkAnnotation';
-      var data = this.data,
-          linkService = this.linkService;
-      var link = document.createElement('a');
-      (0, _display_utils.addLinkAttributes)(link, {
-        url: data.url,
-        target: data.newWindow ? _display_utils.LinkTarget.BLANK : linkService.externalLinkTarget,
-        rel: linkService.externalLinkRel
-      });
-
-      if (!data.url) {
-        if (data.action) {
-          this._bindNamedAction(link, data.action);
-        } else {
-          this._bindLink(link, data.dest);
-        }
-      }
-
-      this.container.appendChild(link);
-      return this.container;
-    }
-  }, {
-    key: "_bindLink",
-    value: function _bindLink(link, destination) {
-      var _this = this;
-
-      link.href = this.linkService.getDestinationHash(destination);
-
-      link.onclick = function () {
-        if (destination) {
-          _this.linkService.navigateTo(destination);
-        }
-
-        return false;
-      };
-
-      if (destination) {
-        link.className = 'internalLink';
-      }
-    }
-  }, {
-    key: "_bindNamedAction",
-    value: function _bindNamedAction(link, action) {
-      var _this2 = this;
-
-      link.href = this.linkService.getAnchorUrl('');
-
-      link.onclick = function () {
-        _this2.linkService.executeNamedAction(action);
-
-        return false;
-      };
-
-      link.className = 'internalLink';
-    }
-  }]);
-
-  return LinkAnnotationElement;
-}(AnnotationElement);
-
-var TextAnnotationElement =
-/*#__PURE__*/
-function (_AnnotationElement2) {
-  _inherits(TextAnnotationElement, _AnnotationElement2);
-
-  function TextAnnotationElement(parameters) {
-    _classCallCheck(this, TextAnnotationElement);
-
-    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, _getPrototypeOf(TextAnnotationElement).call(this, parameters, isRenderable));
-  }
-
-  _createClass(TextAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = 'textAnnotation';
-      var image = document.createElement('img');
-      image.style.height = this.container.style.height;
-      image.style.width = this.container.style.width;
-      image.src = this.imageResourcesPath + 'annotation-' + this.data.name.toLowerCase() + '.svg';
-      image.alt = '[{{type}} Annotation]';
-      image.dataset.l10nId = 'text_annotation_type';
-      image.dataset.l10nArgs = JSON.stringify({
-        type: this.data.name
-      });
-
-      if (!this.data.hasPopup) {
-        this._createPopup(this.container, image, this.data);
-      }
-
-      this.container.appendChild(image);
-      return this.container;
-    }
-  }]);
-
-  return TextAnnotationElement;
-}(AnnotationElement);
-
-var WidgetAnnotationElement =
-/*#__PURE__*/
-function (_AnnotationElement3) {
-  _inherits(WidgetAnnotationElement, _AnnotationElement3);
-
-  function WidgetAnnotationElement() {
-    _classCallCheck(this, WidgetAnnotationElement);
-
-    return _possibleConstructorReturn(this, _getPrototypeOf(WidgetAnnotationElement).apply(this, arguments));
-  }
-
-  _createClass(WidgetAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      return this.container;
-    }
-  }]);
-
-  return WidgetAnnotationElement;
-}(AnnotationElement);
-
-var TextWidgetAnnotationElement =
-/*#__PURE__*/
-function (_WidgetAnnotationElem) {
-  _inherits(TextWidgetAnnotationElement, _WidgetAnnotationElem);
-
-  function TextWidgetAnnotationElement(parameters) {
-    _classCallCheck(this, TextWidgetAnnotationElement);
-
-    var isRenderable = parameters.renderInteractiveForms || !parameters.data.hasAppearance && !!parameters.data.fieldValue;
-    return _possibleConstructorReturn(this, _getPrototypeOf(TextWidgetAnnotationElement).call(this, parameters, isRenderable));
-  }
-
-  _createClass(TextWidgetAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      var TEXT_ALIGNMENT = ['left', 'center', 'right'];
-      this.container.className = 'textWidgetAnnotation';
-      var element = null;
-
-      if (this.renderInteractiveForms) {
-        if (this.data.multiLine) {
-          element = document.createElement('textarea');
-          element.textContent = this.data.fieldValue;
-        } else {
-          element = document.createElement('input');
-          element.type = 'text';
-          element.setAttribute('value', this.data.fieldValue);
-        }
-
-        element.disabled = this.data.readOnly;
-
-        if (this.data.maxLen !== null) {
-          element.maxLength = this.data.maxLen;
-        }
-
-        if (this.data.comb) {
-          var fieldWidth = this.data.rect[2] - this.data.rect[0];
-          var combWidth = fieldWidth / this.data.maxLen;
-          element.classList.add('comb');
-          element.style.letterSpacing = 'calc(' + combWidth + 'px - 1ch)';
-        }
-      } else {
-        element = document.createElement('div');
-        element.textContent = this.data.fieldValue;
-        element.style.verticalAlign = 'middle';
-        element.style.display = 'table-cell';
-        var font = null;
-
-        if (this.data.fontRefName && this.page.commonObjs.has(this.data.fontRefName)) {
-          font = this.page.commonObjs.get(this.data.fontRefName);
-        }
-
-        this._setTextStyle(element, font);
-      }
-
-      if (this.data.textAlignment !== null) {
-        element.style.textAlign = TEXT_ALIGNMENT[this.data.textAlignment];
-      }
-
-      this.container.appendChild(element);
-      return this.container;
-    }
-  }, {
-    key: "_setTextStyle",
-    value: function _setTextStyle(element, font) {
-      var style = element.style;
-      style.fontSize = this.data.fontSize + 'px';
-      style.direction = this.data.fontDirection < 0 ? 'rtl' : 'ltr';
-
-      if (!font) {
-        return;
-      }
-
-      style.fontWeight = font.black ? font.bold ? '900' : 'bold' : font.bold ? 'bold' : 'normal';
-      style.fontStyle = font.italic ? 'italic' : 'normal';
-      var fontFamily = font.loadedName ? '"' + font.loadedName + '", ' : '';
-      var fallbackName = font.fallbackName || 'Helvetica, sans-serif';
-      style.fontFamily = fontFamily + fallbackName;
-    }
-  }]);
-
-  return TextWidgetAnnotationElement;
-}(WidgetAnnotationElement);
-
-var CheckboxWidgetAnnotationElement =
-/*#__PURE__*/
-function (_WidgetAnnotationElem2) {
-  _inherits(CheckboxWidgetAnnotationElement, _WidgetAnnotationElem2);
-
-  function CheckboxWidgetAnnotationElement(parameters) {
-    _classCallCheck(this, CheckboxWidgetAnnotationElement);
-
-    return _possibleConstructorReturn(this, _getPrototypeOf(CheckboxWidgetAnnotationElement).call(this, parameters, parameters.renderInteractiveForms));
-  }
-
-  _createClass(CheckboxWidgetAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = 'buttonWidgetAnnotation checkBox';
-      var element = document.createElement('input');
-      element.disabled = this.data.readOnly;
-      element.type = 'checkbox';
-
-      if (this.data.fieldValue && this.data.fieldValue !== 'Off') {
-        element.setAttribute('checked', true);
-      }
-
-      this.container.appendChild(element);
-      return this.container;
-    }
-  }]);
-
-  return CheckboxWidgetAnnotationElement;
-}(WidgetAnnotationElement);
-
-var RadioButtonWidgetAnnotationElement =
-/*#__PURE__*/
-function (_WidgetAnnotationElem3) {
-  _inherits(RadioButtonWidgetAnnotationElement, _WidgetAnnotationElem3);
-
-  function RadioButtonWidgetAnnotationElement(parameters) {
-    _classCallCheck(this, RadioButtonWidgetAnnotationElement);
-
-    return _possibleConstructorReturn(this, _getPrototypeOf(RadioButtonWidgetAnnotationElement).call(this, parameters, parameters.renderInteractiveForms));
-  }
-
-  _createClass(RadioButtonWidgetAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = 'buttonWidgetAnnotation radioButton';
-      var element = document.createElement('input');
-      element.disabled = this.data.readOnly;
-      element.type = 'radio';
-      element.name = this.data.fieldName;
-
-      if (this.data.fieldValue === this.data.buttonValue) {
-        element.setAttribute('checked', true);
-      }
-
-      this.container.appendChild(element);
-      return this.container;
-    }
-  }]);
-
-  return RadioButtonWidgetAnnotationElement;
-}(WidgetAnnotationElement);
-
-var PushButtonWidgetAnnotationElement =
-/*#__PURE__*/
-function (_LinkAnnotationElemen) {
-  _inherits(PushButtonWidgetAnnotationElement, _LinkAnnotationElemen);
-
-  function PushButtonWidgetAnnotationElement() {
-    _classCallCheck(this, PushButtonWidgetAnnotationElement);
-
-    return _possibleConstructorReturn(this, _getPrototypeOf(PushButtonWidgetAnnotationElement).apply(this, arguments));
-  }
-
-  _createClass(PushButtonWidgetAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      var container = _get(_getPrototypeOf(PushButtonWidgetAnnotationElement.prototype), "render", this).call(this);
-
-      container.className = 'buttonWidgetAnnotation pushButton';
-      return container;
-    }
-  }]);
-
-  return PushButtonWidgetAnnotationElement;
-}(LinkAnnotationElement);
-
-var ChoiceWidgetAnnotationElement =
-/*#__PURE__*/
-function (_WidgetAnnotationElem4) {
-  _inherits(ChoiceWidgetAnnotationElement, _WidgetAnnotationElem4);
-
-  function ChoiceWidgetAnnotationElement(parameters) {
-    _classCallCheck(this, ChoiceWidgetAnnotationElement);
-
-    return _possibleConstructorReturn(this, _getPrototypeOf(ChoiceWidgetAnnotationElement).call(this, parameters, parameters.renderInteractiveForms));
-  }
-
-  _createClass(ChoiceWidgetAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = 'choiceWidgetAnnotation';
-      var selectElement = document.createElement('select');
-      selectElement.disabled = this.data.readOnly;
-
-      if (!this.data.combo) {
-        selectElement.size = this.data.options.length;
-
-        if (this.data.multiSelect) {
-          selectElement.multiple = true;
-        }
-      }
-
-      for (var i = 0, ii = this.data.options.length; i < ii; i++) {
-        var option = this.data.options[i];
-        var optionElement = document.createElement('option');
-        optionElement.textContent = option.displayValue;
-        optionElement.value = option.exportValue;
-
-        if (this.data.fieldValue.includes(option.displayValue)) {
-          optionElement.setAttribute('selected', true);
-        }
-
-        selectElement.appendChild(optionElement);
-      }
-
-      this.container.appendChild(selectElement);
-      return this.container;
-    }
-  }]);
-
-  return ChoiceWidgetAnnotationElement;
-}(WidgetAnnotationElement);
-
-var PopupAnnotationElement =
-/*#__PURE__*/
-function (_AnnotationElement4) {
-  _inherits(PopupAnnotationElement, _AnnotationElement4);
-
-  function PopupAnnotationElement(parameters) {
-    _classCallCheck(this, PopupAnnotationElement);
-
-    var isRenderable = !!(parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, _getPrototypeOf(PopupAnnotationElement).call(this, parameters, isRenderable));
-  }
-
-  _createClass(PopupAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      var IGNORE_TYPES = ['Line', 'Square', 'Circle', 'PolyLine', 'Polygon', 'Ink'];
-      this.container.className = 'popupAnnotation';
-
-      if (IGNORE_TYPES.includes(this.data.parentType)) {
-        return this.container;
-      }
-
-      var selector = '[data-annotation-id="' + this.data.parentId + '"]';
-      var parentElement = this.layer.querySelector(selector);
-
-      if (!parentElement) {
-        return this.container;
-      }
-
-      var popup = new PopupElement({
-        container: this.container,
-        trigger: parentElement,
-        color: this.data.color,
-        title: this.data.title,
-        modificationDate: this.data.modificationDate,
-        contents: this.data.contents
-      });
-      var parentLeft = parseFloat(parentElement.style.left);
-      var parentWidth = parseFloat(parentElement.style.width);
-      this.container.style.transformOrigin = -(parentLeft + parentWidth) + 'px -' + parentElement.style.top;
-      this.container.style.left = parentLeft + parentWidth + 'px';
-      this.container.appendChild(popup.render());
-      return this.container;
-    }
-  }]);
-
-  return PopupAnnotationElement;
-}(AnnotationElement);
-
-var PopupElement =
-/*#__PURE__*/
-function () {
-  function PopupElement(parameters) {
-    _classCallCheck(this, PopupElement);
-
-    this.container = parameters.container;
-    this.trigger = parameters.trigger;
-    this.color = parameters.color;
-    this.title = parameters.title;
-    this.modificationDate = parameters.modificationDate;
-    this.contents = parameters.contents;
-    this.hideWrapper = parameters.hideWrapper || false;
-    this.pinned = false;
-  }
-
-  _createClass(PopupElement, [{
-    key: "render",
-    value: function render() {
-      var BACKGROUND_ENLIGHT = 0.7;
-      var wrapper = document.createElement('div');
-      wrapper.className = 'popupWrapper';
-      this.hideElement = this.hideWrapper ? wrapper : this.container;
-      this.hideElement.setAttribute('hidden', true);
-      var popup = document.createElement('div');
-      popup.className = 'popup';
-      var color = this.color;
-
-      if (color) {
-        var r = BACKGROUND_ENLIGHT * (255 - color[0]) + color[0];
-        var g = BACKGROUND_ENLIGHT * (255 - color[1]) + color[1];
-        var b = BACKGROUND_ENLIGHT * (255 - color[2]) + color[2];
-        popup.style.backgroundColor = _util.Util.makeCssRgb(r | 0, g | 0, b | 0);
-      }
-
-      var title = document.createElement('h1');
-      title.textContent = this.title;
-      popup.appendChild(title);
-
-      var dateObject = _display_utils.PDFDateString.toDateObject(this.modificationDate);
-
-      if (dateObject) {
-        var modificationDate = document.createElement('span');
-        modificationDate.textContent = '{{date}}, {{time}}';
-        modificationDate.dataset.l10nId = 'annotation_date_string';
-        modificationDate.dataset.l10nArgs = JSON.stringify({
-          date: dateObject.toLocaleDateString(),
-          time: dateObject.toLocaleTimeString()
-        });
-        popup.appendChild(modificationDate);
-      }
-
-      var contents = this._formatContents(this.contents);
-
-      popup.appendChild(contents);
-      this.trigger.addEventListener('click', this._toggle.bind(this));
-      this.trigger.addEventListener('mouseover', this._show.bind(this, false));
-      this.trigger.addEventListener('mouseout', this._hide.bind(this, false));
-      popup.addEventListener('click', this._hide.bind(this, true));
-      wrapper.appendChild(popup);
-      return wrapper;
-    }
-  }, {
-    key: "_formatContents",
-    value: function _formatContents(contents) {
-      var p = document.createElement('p');
-      var lines = contents.split(/(?:\r\n?|\n)/);
-
-      for (var i = 0, ii = lines.length; i < ii; ++i) {
-        var line = lines[i];
-        p.appendChild(document.createTextNode(line));
-
-        if (i < ii - 1) {
-          p.appendChild(document.createElement('br'));
-        }
-      }
-
-      return p;
-    }
-  }, {
-    key: "_toggle",
-    value: function _toggle() {
-      if (this.pinned) {
-        this._hide(true);
-      } else {
-        this._show(true);
-      }
-    }
-  }, {
-    key: "_show",
-    value: function _show() {
-      var pin = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
-
-      if (pin) {
-        this.pinned = true;
-      }
-
-      if (this.hideElement.hasAttribute('hidden')) {
-        this.hideElement.removeAttribute('hidden');
-        this.container.style.zIndex += 1;
-      }
-    }
-  }, {
-    key: "_hide",
-    value: function _hide() {
-      var unpin = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
-
-      if (unpin) {
-        this.pinned = false;
-      }
-
-      if (!this.hideElement.hasAttribute('hidden') && !this.pinned) {
-        this.hideElement.setAttribute('hidden', true);
-        this.container.style.zIndex -= 1;
-      }
-    }
-  }]);
-
-  return PopupElement;
-}();
-
-var FreeTextAnnotationElement =
-/*#__PURE__*/
-function (_AnnotationElement5) {
-  _inherits(FreeTextAnnotationElement, _AnnotationElement5);
-
-  function FreeTextAnnotationElement(parameters) {
-    _classCallCheck(this, FreeTextAnnotationElement);
-
-    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, _getPrototypeOf(FreeTextAnnotationElement).call(this, parameters, isRenderable, true));
-  }
-
-  _createClass(FreeTextAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = 'freeTextAnnotation';
-
-      if (!this.data.hasPopup) {
-        this._createPopup(this.container, null, this.data);
-      }
-
-      return this.container;
-    }
-  }]);
-
-  return FreeTextAnnotationElement;
-}(AnnotationElement);
-
-var LineAnnotationElement =
-/*#__PURE__*/
-function (_AnnotationElement6) {
-  _inherits(LineAnnotationElement, _AnnotationElement6);
-
-  function LineAnnotationElement(parameters) {
-    _classCallCheck(this, LineAnnotationElement);
-
-    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, _getPrototypeOf(LineAnnotationElement).call(this, parameters, isRenderable, true));
-  }
-
-  _createClass(LineAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = 'lineAnnotation';
-      var data = this.data;
-      var width = data.rect[2] - data.rect[0];
-      var height = data.rect[3] - data.rect[1];
-      var svg = this.svgFactory.create(width, height);
-      var line = this.svgFactory.createElement('svg:line');
-      line.setAttribute('x1', data.rect[2] - data.lineCoordinates[0]);
-      line.setAttribute('y1', data.rect[3] - data.lineCoordinates[1]);
-      line.setAttribute('x2', data.rect[2] - data.lineCoordinates[2]);
-      line.setAttribute('y2', data.rect[3] - data.lineCoordinates[3]);
-      line.setAttribute('stroke-width', data.borderStyle.width);
-      line.setAttribute('stroke', 'transparent');
-      svg.appendChild(line);
-      this.container.append(svg);
-
-      this._createPopup(this.container, line, data);
-
-      return this.container;
-    }
-  }]);
-
-  return LineAnnotationElement;
-}(AnnotationElement);
-
-var SquareAnnotationElement =
-/*#__PURE__*/
-function (_AnnotationElement7) {
-  _inherits(SquareAnnotationElement, _AnnotationElement7);
-
-  function SquareAnnotationElement(parameters) {
-    _classCallCheck(this, SquareAnnotationElement);
-
-    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, _getPrototypeOf(SquareAnnotationElement).call(this, parameters, isRenderable, true));
-  }
-
-  _createClass(SquareAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = 'squareAnnotation';
-      var data = this.data;
-      var width = data.rect[2] - data.rect[0];
-      var height = data.rect[3] - data.rect[1];
-      var svg = this.svgFactory.create(width, height);
-      var borderWidth = data.borderStyle.width;
-      var square = this.svgFactory.createElement('svg:rect');
-      square.setAttribute('x', borderWidth / 2);
-      square.setAttribute('y', borderWidth / 2);
-      square.setAttribute('width', width - borderWidth);
-      square.setAttribute('height', height - borderWidth);
-      square.setAttribute('stroke-width', borderWidth);
-      square.setAttribute('stroke', 'transparent');
-      square.setAttribute('fill', 'none');
-      svg.appendChild(square);
-      this.container.append(svg);
-
-      this._createPopup(this.container, square, data);
-
-      return this.container;
-    }
-  }]);
-
-  return SquareAnnotationElement;
-}(AnnotationElement);
-
-var CircleAnnotationElement =
-/*#__PURE__*/
-function (_AnnotationElement8) {
-  _inherits(CircleAnnotationElement, _AnnotationElement8);
-
-  function CircleAnnotationElement(parameters) {
-    _classCallCheck(this, CircleAnnotationElement);
-
-    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, _getPrototypeOf(CircleAnnotationElement).call(this, parameters, isRenderable, true));
-  }
-
-  _createClass(CircleAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = 'circleAnnotation';
-      var data = this.data;
-      var width = data.rect[2] - data.rect[0];
-      var height = data.rect[3] - data.rect[1];
-      var svg = this.svgFactory.create(width, height);
-      var borderWidth = data.borderStyle.width;
-      var circle = this.svgFactory.createElement('svg:ellipse');
-      circle.setAttribute('cx', width / 2);
-      circle.setAttribute('cy', height / 2);
-      circle.setAttribute('rx', width / 2 - borderWidth / 2);
-      circle.setAttribute('ry', height / 2 - borderWidth / 2);
-      circle.setAttribute('stroke-width', borderWidth);
-      circle.setAttribute('stroke', 'transparent');
-      circle.setAttribute('fill', 'none');
-      svg.appendChild(circle);
-      this.container.append(svg);
-
-      this._createPopup(this.container, circle, data);
-
-      return this.container;
-    }
-  }]);
-
-  return CircleAnnotationElement;
-}(AnnotationElement);
-
-var PolylineAnnotationElement =
-/*#__PURE__*/
-function (_AnnotationElement9) {
-  _inherits(PolylineAnnotationElement, _AnnotationElement9);
-
-  function PolylineAnnotationElement(parameters) {
-    var _this3;
-
-    _classCallCheck(this, PolylineAnnotationElement);
-
-    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    _this3 = _possibleConstructorReturn(this, _getPrototypeOf(PolylineAnnotationElement).call(this, parameters, isRenderable, true));
-    _this3.containerClassName = 'polylineAnnotation';
-    _this3.svgElementName = 'svg:polyline';
-    return _this3;
-  }
-
-  _createClass(PolylineAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = this.containerClassName;
-      var data = this.data;
-      var width = data.rect[2] - data.rect[0];
-      var height = data.rect[3] - data.rect[1];
-      var svg = this.svgFactory.create(width, height);
-      var vertices = data.vertices;
-      var points = [];
-
-      for (var i = 0, ii = vertices.length; i < ii; i++) {
-        var x = vertices[i].x - data.rect[0];
-        var y = data.rect[3] - vertices[i].y;
-        points.push(x + ',' + y);
-      }
-
-      points = points.join(' ');
-      var borderWidth = data.borderStyle.width;
-      var polyline = this.svgFactory.createElement(this.svgElementName);
-      polyline.setAttribute('points', points);
-      polyline.setAttribute('stroke-width', borderWidth);
-      polyline.setAttribute('stroke', 'transparent');
-      polyline.setAttribute('fill', 'none');
-      svg.appendChild(polyline);
-      this.container.append(svg);
-
-      this._createPopup(this.container, polyline, data);
-
-      return this.container;
-    }
-  }]);
-
-  return PolylineAnnotationElement;
-}(AnnotationElement);
-
-var PolygonAnnotationElement =
-/*#__PURE__*/
-function (_PolylineAnnotationEl) {
-  _inherits(PolygonAnnotationElement, _PolylineAnnotationEl);
-
-  function PolygonAnnotationElement(parameters) {
-    var _this4;
-
-    _classCallCheck(this, PolygonAnnotationElement);
-
-    _this4 = _possibleConstructorReturn(this, _getPrototypeOf(PolygonAnnotationElement).call(this, parameters));
-    _this4.containerClassName = 'polygonAnnotation';
-    _this4.svgElementName = 'svg:polygon';
-    return _this4;
-  }
-
-  return PolygonAnnotationElement;
-}(PolylineAnnotationElement);
-
-var CaretAnnotationElement =
-/*#__PURE__*/
-function (_AnnotationElement10) {
-  _inherits(CaretAnnotationElement, _AnnotationElement10);
-
-  function CaretAnnotationElement(parameters) {
-    _classCallCheck(this, CaretAnnotationElement);
-
-    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, _getPrototypeOf(CaretAnnotationElement).call(this, parameters, isRenderable, true));
-  }
-
-  _createClass(CaretAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = 'caretAnnotation';
-
-      if (!this.data.hasPopup) {
-        this._createPopup(this.container, null, this.data);
-      }
-
-      return this.container;
-    }
-  }]);
-
-  return CaretAnnotationElement;
-}(AnnotationElement);
-
-var InkAnnotationElement =
-/*#__PURE__*/
-function (_AnnotationElement11) {
-  _inherits(InkAnnotationElement, _AnnotationElement11);
-
-  function InkAnnotationElement(parameters) {
-    var _this5;
-
-    _classCallCheck(this, InkAnnotationElement);
-
-    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    _this5 = _possibleConstructorReturn(this, _getPrototypeOf(InkAnnotationElement).call(this, parameters, isRenderable, true));
-    _this5.containerClassName = 'inkAnnotation';
-    _this5.svgElementName = 'svg:polyline';
-    return _this5;
-  }
-
-  _createClass(InkAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = this.containerClassName;
-      var data = this.data;
-      var width = data.rect[2] - data.rect[0];
-      var height = data.rect[3] - data.rect[1];
-      var svg = this.svgFactory.create(width, height);
-      var inkLists = data.inkLists;
-
-      for (var i = 0, ii = inkLists.length; i < ii; i++) {
-        var inkList = inkLists[i];
-        var points = [];
-
-        for (var j = 0, jj = inkList.length; j < jj; j++) {
-          var x = inkList[j].x - data.rect[0];
-          var y = data.rect[3] - inkList[j].y;
-          points.push(x + ',' + y);
-        }
-
-        points = points.join(' ');
-        var borderWidth = data.borderStyle.width;
-        var polyline = this.svgFactory.createElement(this.svgElementName);
-        polyline.setAttribute('points', points);
-        polyline.setAttribute('stroke-width', borderWidth);
-        polyline.setAttribute('stroke', 'transparent');
-        polyline.setAttribute('fill', 'none');
-
-        this._createPopup(this.container, polyline, data);
-
-        svg.appendChild(polyline);
-      }
-
-      this.container.append(svg);
-      return this.container;
-    }
-  }]);
-
-  return InkAnnotationElement;
-}(AnnotationElement);
-
-var HighlightAnnotationElement =
-/*#__PURE__*/
-function (_AnnotationElement12) {
-  _inherits(HighlightAnnotationElement, _AnnotationElement12);
-
-  function HighlightAnnotationElement(parameters) {
-    _classCallCheck(this, HighlightAnnotationElement);
-
-    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, _getPrototypeOf(HighlightAnnotationElement).call(this, parameters, isRenderable, true));
-  }
-
-  _createClass(HighlightAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = 'highlightAnnotation';
-
-      if (!this.data.hasPopup) {
-        this._createPopup(this.container, null, this.data);
-      }
-
-      return this.container;
-    }
-  }]);
-
-  return HighlightAnnotationElement;
-}(AnnotationElement);
-
-var UnderlineAnnotationElement =
-/*#__PURE__*/
-function (_AnnotationElement13) {
-  _inherits(UnderlineAnnotationElement, _AnnotationElement13);
-
-  function UnderlineAnnotationElement(parameters) {
-    _classCallCheck(this, UnderlineAnnotationElement);
-
-    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, _getPrototypeOf(UnderlineAnnotationElement).call(this, parameters, isRenderable, true));
-  }
-
-  _createClass(UnderlineAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = 'underlineAnnotation';
-
-      if (!this.data.hasPopup) {
-        this._createPopup(this.container, null, this.data);
-      }
-
-      return this.container;
-    }
-  }]);
-
-  return UnderlineAnnotationElement;
-}(AnnotationElement);
-
-var SquigglyAnnotationElement =
-/*#__PURE__*/
-function (_AnnotationElement14) {
-  _inherits(SquigglyAnnotationElement, _AnnotationElement14);
-
-  function SquigglyAnnotationElement(parameters) {
-    _classCallCheck(this, SquigglyAnnotationElement);
-
-    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, _getPrototypeOf(SquigglyAnnotationElement).call(this, parameters, isRenderable, true));
-  }
-
-  _createClass(SquigglyAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = 'squigglyAnnotation';
-
-      if (!this.data.hasPopup) {
-        this._createPopup(this.container, null, this.data);
-      }
-
-      return this.container;
-    }
-  }]);
-
-  return SquigglyAnnotationElement;
-}(AnnotationElement);
-
-var StrikeOutAnnotationElement =
-/*#__PURE__*/
-function (_AnnotationElement15) {
-  _inherits(StrikeOutAnnotationElement, _AnnotationElement15);
-
-  function StrikeOutAnnotationElement(parameters) {
-    _classCallCheck(this, StrikeOutAnnotationElement);
-
-    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, _getPrototypeOf(StrikeOutAnnotationElement).call(this, parameters, isRenderable, true));
-  }
-
-  _createClass(StrikeOutAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = 'strikeoutAnnotation';
-
-      if (!this.data.hasPopup) {
-        this._createPopup(this.container, null, this.data);
-      }
-
-      return this.container;
-    }
-  }]);
-
-  return StrikeOutAnnotationElement;
-}(AnnotationElement);
-
-var StampAnnotationElement =
-/*#__PURE__*/
-function (_AnnotationElement16) {
-  _inherits(StampAnnotationElement, _AnnotationElement16);
-
-  function StampAnnotationElement(parameters) {
-    _classCallCheck(this, StampAnnotationElement);
-
-    var isRenderable = !!(parameters.data.hasPopup || parameters.data.title || parameters.data.contents);
-    return _possibleConstructorReturn(this, _getPrototypeOf(StampAnnotationElement).call(this, parameters, isRenderable, true));
-  }
-
-  _createClass(StampAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = 'stampAnnotation';
-
-      if (!this.data.hasPopup) {
-        this._createPopup(this.container, null, this.data);
-      }
-
-      return this.container;
-    }
-  }]);
-
-  return StampAnnotationElement;
-}(AnnotationElement);
-
-var FileAttachmentAnnotationElement =
-/*#__PURE__*/
-function (_AnnotationElement17) {
-  _inherits(FileAttachmentAnnotationElement, _AnnotationElement17);
-
-  function FileAttachmentAnnotationElement(parameters) {
-    var _this6;
-
-    _classCallCheck(this, FileAttachmentAnnotationElement);
-
-    _this6 = _possibleConstructorReturn(this, _getPrototypeOf(FileAttachmentAnnotationElement).call(this, parameters, true));
-    var _this6$data$file = _this6.data.file,
-        filename = _this6$data$file.filename,
-        content = _this6$data$file.content;
-    _this6.filename = (0, _display_utils.getFilenameFromUrl)(filename);
-    _this6.content = content;
-
-    if (_this6.linkService.eventBus) {
-      _this6.linkService.eventBus.dispatch('fileattachmentannotation', {
-        source: _assertThisInitialized(_this6),
-        id: (0, _util.stringToPDFString)(filename),
-        filename: filename,
-        content: content
-      });
-    }
-
-    return _this6;
-  }
-
-  _createClass(FileAttachmentAnnotationElement, [{
-    key: "render",
-    value: function render() {
-      this.container.className = 'fileAttachmentAnnotation';
-      var trigger = document.createElement('div');
-      trigger.style.height = this.container.style.height;
-      trigger.style.width = this.container.style.width;
-      trigger.addEventListener('dblclick', this._download.bind(this));
-
-      if (!this.data.hasPopup && (this.data.title || this.data.contents)) {
-        this._createPopup(this.container, trigger, this.data);
-      }
-
-      this.container.appendChild(trigger);
-      return this.container;
-    }
-  }, {
-    key: "_download",
-    value: function _download() {
-      if (!this.downloadManager) {
-        (0, _util.warn)('Download cannot be started due to unavailable download manager');
-        return;
-      }
-
-      this.downloadManager.downloadData(this.content, this.filename, '');
-    }
-  }]);
-
-  return FileAttachmentAnnotationElement;
-}(AnnotationElement);
-
-var AnnotationLayer =
-/*#__PURE__*/
-function () {
-  function AnnotationLayer() {
-    _classCallCheck(this, AnnotationLayer);
-  }
-
-  _createClass(AnnotationLayer, null, [{
-    key: "render",
-    value: function render(parameters) {
-      for (var i = 0, ii = parameters.annotations.length; i < ii; i++) {
-        var data = parameters.annotations[i];
-
-        if (!data) {
-          continue;
-        }
-
-        var element = AnnotationElementFactory.create({
-          data: data,
-          layer: parameters.div,
-          page: parameters.page,
-          viewport: parameters.viewport,
-          linkService: parameters.linkService,
-          downloadManager: parameters.downloadManager,
-          imageResourcesPath: parameters.imageResourcesPath || '',
-          renderInteractiveForms: parameters.renderInteractiveForms || false,
-          svgFactory: new _display_utils.DOMSVGFactory()
-        });
-
-        if (element.isRenderable) {
-          parameters.div.appendChild(element.render());
-        }
-      }
-    }
-  }, {
-    key: "update",
-    value: function update(parameters) {
-      for (var i = 0, ii = parameters.annotations.length; i < ii; i++) {
-        var data = parameters.annotations[i];
-        var element = parameters.div.querySelector('[data-annotation-id="' + data.id + '"]');
-
-        if (element) {
-          element.style.transform = 'matrix(' + parameters.viewport.transform.join(',') + ')';
-        }
-      }
-
-      parameters.div.removeAttribute('hidden');
-    }
-  }]);
-
-  return AnnotationLayer;
-}();
-
-exports.AnnotationLayer = AnnotationLayer;
-
-/***/ }),
-/* 164 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.SVGGraphics = void 0;
-
-var _util = __w_pdfjs_require__(1);
-
-var _display_utils = __w_pdfjs_require__(151);
-
-var _is_node = _interopRequireDefault(__w_pdfjs_require__(4));
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { "default": obj }; }
-
-function _toConsumableArray(arr) { return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _nonIterableSpread(); }
-
-function _nonIterableSpread() { throw new TypeError("Invalid attempt to spread non-iterable instance"); }
-
-function _iterableToArray(iter) { if (Symbol.iterator in Object(iter) || Object.prototype.toString.call(iter) === "[object Arguments]") return Array.from(iter); }
-
-function _arrayWithoutHoles(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = new Array(arr.length); i < arr.length; i++) { arr2[i] = arr[i]; } return arr2; } }
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
-
-function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-var SVGGraphics = function SVGGraphics() {
-  throw new Error('Not implemented: SVGGraphics');
-};
-
-exports.SVGGraphics = SVGGraphics;
-{
-  var opListToTree = function opListToTree(opList) {
-    var opTree = [];
-    var tmp = [];
-    var _iteratorNormalCompletion = true;
-    var _didIteratorError = false;
-    var _iteratorError = undefined;
-
-    try {
-      for (var _iterator = opList[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-        var opListElement = _step.value;
-
-        if (opListElement.fn === 'save') {
-          opTree.push({
-            'fnId': 92,
-            'fn': 'group',
-            'items': []
-          });
-          tmp.push(opTree);
-          opTree = opTree[opTree.length - 1].items;
-          continue;
-        }
-
-        if (opListElement.fn === 'restore') {
-          opTree = tmp.pop();
-        } else {
-          opTree.push(opListElement);
-        }
-      }
-    } catch (err) {
-      _didIteratorError = true;
-      _iteratorError = err;
-    } finally {
-      try {
-        if (!_iteratorNormalCompletion && _iterator["return"] != null) {
-          _iterator["return"]();
-        }
-      } finally {
-        if (_didIteratorError) {
-          throw _iteratorError;
-        }
-      }
-    }
-
-    return opTree;
-  };
-
-  var pf = function pf(value) {
-    if (Number.isInteger(value)) {
-      return value.toString();
-    }
-
-    var s = value.toFixed(10);
-    var i = s.length - 1;
-
-    if (s[i] !== '0') {
-      return s;
-    }
-
-    do {
-      i--;
-    } while (s[i] === '0');
-
-    return s.substring(0, s[i] === '.' ? i : i + 1);
-  };
-
-  var pm = function pm(m) {
-    if (m[4] === 0 && m[5] === 0) {
-      if (m[1] === 0 && m[2] === 0) {
-        if (m[0] === 1 && m[3] === 1) {
-          return '';
-        }
-
-        return "scale(".concat(pf(m[0]), " ").concat(pf(m[3]), ")");
-      }
-
-      if (m[0] === m[3] && m[1] === -m[2]) {
-        var a = Math.acos(m[0]) * 180 / Math.PI;
-        return "rotate(".concat(pf(a), ")");
-      }
-    } else {
-      if (m[0] === 1 && m[1] === 0 && m[2] === 0 && m[3] === 1) {
-        return "translate(".concat(pf(m[4]), " ").concat(pf(m[5]), ")");
-      }
-    }
-
-    return "matrix(".concat(pf(m[0]), " ").concat(pf(m[1]), " ").concat(pf(m[2]), " ").concat(pf(m[3]), " ").concat(pf(m[4]), " ") + "".concat(pf(m[5]), ")");
-  };
-
-  var SVG_DEFAULTS = {
-    fontStyle: 'normal',
-    fontWeight: 'normal',
-    fillColor: '#000000'
-  };
-  var XML_NS = 'http://www.w3.org/XML/1998/namespace';
-  var XLINK_NS = 'http://www.w3.org/1999/xlink';
-  var LINE_CAP_STYLES = ['butt', 'round', 'square'];
-  var LINE_JOIN_STYLES = ['miter', 'round', 'bevel'];
-
-  var convertImgDataToPng = function () {
-    var PNG_HEADER = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
-    var CHUNK_WRAPPER_SIZE = 12;
-    var crcTable = new Int32Array(256);
-
-    for (var i = 0; i < 256; i++) {
-      var c = i;
-
-      for (var h = 0; h < 8; h++) {
-        if (c & 1) {
-          c = 0xedB88320 ^ c >> 1 & 0x7fffffff;
-        } else {
-          c = c >> 1 & 0x7fffffff;
-        }
-      }
-
-      crcTable[i] = c;
-    }
-
-    function crc32(data, start, end) {
-      var crc = -1;
-
-      for (var _i = start; _i < end; _i++) {
-        var a = (crc ^ data[_i]) & 0xff;
-        var b = crcTable[a];
-        crc = crc >>> 8 ^ b;
-      }
-
-      return crc ^ -1;
-    }
-
-    function writePngChunk(type, body, data, offset) {
-      var p = offset;
-      var len = body.length;
-      data[p] = len >> 24 & 0xff;
-      data[p + 1] = len >> 16 & 0xff;
-      data[p + 2] = len >> 8 & 0xff;
-      data[p + 3] = len & 0xff;
-      p += 4;
-      data[p] = type.charCodeAt(0) & 0xff;
-      data[p + 1] = type.charCodeAt(1) & 0xff;
-      data[p + 2] = type.charCodeAt(2) & 0xff;
-      data[p + 3] = type.charCodeAt(3) & 0xff;
-      p += 4;
-      data.set(body, p);
-      p += body.length;
-      var crc = crc32(data, offset + 4, p);
-      data[p] = crc >> 24 & 0xff;
-      data[p + 1] = crc >> 16 & 0xff;
-      data[p + 2] = crc >> 8 & 0xff;
-      data[p + 3] = crc & 0xff;
-    }
-
-    function adler32(data, start, end) {
-      var a = 1;
-      var b = 0;
-
-      for (var _i2 = start; _i2 < end; ++_i2) {
-        a = (a + (data[_i2] & 0xff)) % 65521;
-        b = (b + a) % 65521;
-      }
-
-      return b << 16 | a;
-    }
-
-    function deflateSync(literals) {
-      if (!(0, _is_node["default"])()) {
-        return deflateSyncUncompressed(literals);
-      }
-
-      try {
-        var input;
-
-        if (parseInt(process.versions.node) >= 8) {
-          input = literals;
-        } else {
-          input = new Buffer(literals);
-        }
-
-        var output = require('zlib').deflateSync(input, {
-          level: 9
-        });
-
-        return output instanceof Uint8Array ? output : new Uint8Array(output);
-      } catch (e) {
-        (0, _util.warn)('Not compressing PNG because zlib.deflateSync is unavailable: ' + e);
-      }
-
-      return deflateSyncUncompressed(literals);
-    }
-
-    function deflateSyncUncompressed(literals) {
-      var len = literals.length;
-      var maxBlockLength = 0xFFFF;
-      var deflateBlocks = Math.ceil(len / maxBlockLength);
-      var idat = new Uint8Array(2 + len + deflateBlocks * 5 + 4);
-      var pi = 0;
-      idat[pi++] = 0x78;
-      idat[pi++] = 0x9c;
-      var pos = 0;
-
-      while (len > maxBlockLength) {
-        idat[pi++] = 0x00;
-        idat[pi++] = 0xff;
-        idat[pi++] = 0xff;
-        idat[pi++] = 0x00;
-        idat[pi++] = 0x00;
-        idat.set(literals.subarray(pos, pos + maxBlockLength), pi);
-        pi += maxBlockLength;
-        pos += maxBlockLength;
-        len -= maxBlockLength;
-      }
-
-      idat[pi++] = 0x01;
-      idat[pi++] = len & 0xff;
-      idat[pi++] = len >> 8 & 0xff;
-      idat[pi++] = ~len & 0xffff & 0xff;
-      idat[pi++] = (~len & 0xffff) >> 8 & 0xff;
-      idat.set(literals.subarray(pos), pi);
-      pi += literals.length - pos;
-      var adler = adler32(literals, 0, literals.length);
-      idat[pi++] = adler >> 24 & 0xff;
-      idat[pi++] = adler >> 16 & 0xff;
-      idat[pi++] = adler >> 8 & 0xff;
-      idat[pi++] = adler & 0xff;
-      return idat;
-    }
-
-    function encode(imgData, kind, forceDataSchema, isMask) {
-      var width = imgData.width;
-      var height = imgData.height;
-      var bitDepth, colorType, lineSize;
-      var bytes = imgData.data;
-
-      switch (kind) {
-        case _util.ImageKind.GRAYSCALE_1BPP:
-          colorType = 0;
-          bitDepth = 1;
-          lineSize = width + 7 >> 3;
-          break;
-
-        case _util.ImageKind.RGB_24BPP:
-          colorType = 2;
-          bitDepth = 8;
-          lineSize = width * 3;
-          break;
-
-        case _util.ImageKind.RGBA_32BPP:
-          colorType = 6;
-          bitDepth = 8;
-          lineSize = width * 4;
-          break;
-
-        default:
-          throw new Error('invalid format');
-      }
-
-      var literals = new Uint8Array((1 + lineSize) * height);
-      var offsetLiterals = 0,
-          offsetBytes = 0;
-
-      for (var y = 0; y < height; ++y) {
-        literals[offsetLiterals++] = 0;
-        literals.set(bytes.subarray(offsetBytes, offsetBytes + lineSize), offsetLiterals);
-        offsetBytes += lineSize;
-        offsetLiterals += lineSize;
-      }
-
-      if (kind === _util.ImageKind.GRAYSCALE_1BPP && isMask) {
-        offsetLiterals = 0;
-
-        for (var _y = 0; _y < height; _y++) {
-          offsetLiterals++;
-
-          for (var _i3 = 0; _i3 < lineSize; _i3++) {
-            literals[offsetLiterals++] ^= 0xFF;
-          }
-        }
-      }
-
-      var ihdr = new Uint8Array([width >> 24 & 0xff, width >> 16 & 0xff, width >> 8 & 0xff, width & 0xff, height >> 24 & 0xff, height >> 16 & 0xff, height >> 8 & 0xff, height & 0xff, bitDepth, colorType, 0x00, 0x00, 0x00]);
-      var idat = deflateSync(literals);
-      var pngLength = PNG_HEADER.length + CHUNK_WRAPPER_SIZE * 3 + ihdr.length + idat.length;
-      var data = new Uint8Array(pngLength);
-      var offset = 0;
-      data.set(PNG_HEADER, offset);
-      offset += PNG_HEADER.length;
-      writePngChunk('IHDR', ihdr, data, offset);
-      offset += CHUNK_WRAPPER_SIZE + ihdr.length;
-      writePngChunk('IDATA', idat, data, offset);
-      offset += CHUNK_WRAPPER_SIZE + idat.length;
-      writePngChunk('IEND', new Uint8Array(0), data, offset);
-      return (0, _util.createObjectURL)(data, 'image/png', forceDataSchema);
-    }
-
-    return function convertImgDataToPng(imgData, forceDataSchema, isMask) {
-      var kind = imgData.kind === undefined ? _util.ImageKind.GRAYSCALE_1BPP : imgData.kind;
-      return encode(imgData, kind, forceDataSchema, isMask);
-    };
-  }();
-
-  var SVGExtraState =
-  /*#__PURE__*/
-  function () {
-    function SVGExtraState() {
-      _classCallCheck(this, SVGExtraState);
-
-      this.fontSizeScale = 1;
-      this.fontWeight = SVG_DEFAULTS.fontWeight;
-      this.fontSize = 0;
-      this.textMatrix = _util.IDENTITY_MATRIX;
-      this.fontMatrix = _util.FONT_IDENTITY_MATRIX;
-      this.leading = 0;
-      this.textRenderingMode = _util.TextRenderingMode.FILL;
-      this.textMatrixScale = 1;
-      this.x = 0;
-      this.y = 0;
-      this.lineX = 0;
-      this.lineY = 0;
-      this.charSpacing = 0;
-      this.wordSpacing = 0;
-      this.textHScale = 1;
-      this.textRise = 0;
-      this.fillColor = SVG_DEFAULTS.fillColor;
-      this.strokeColor = '#000000';
-      this.fillAlpha = 1;
-      this.strokeAlpha = 1;
-      this.lineWidth = 1;
-      this.lineJoin = '';
-      this.lineCap = '';
-      this.miterLimit = 0;
-      this.dashArray = [];
-      this.dashPhase = 0;
-      this.dependencies = [];
-      this.activeClipUrl = null;
-      this.clipGroup = null;
-      this.maskId = '';
-    }
-
-    _createClass(SVGExtraState, [{
-      key: "clone",
-      value: function clone() {
-        return Object.create(this);
-      }
-    }, {
-      key: "setCurrentPoint",
-      value: function setCurrentPoint(x, y) {
-        this.x = x;
-        this.y = y;
-      }
-    }]);
-
-    return SVGExtraState;
-  }();
-
-  var clipCount = 0;
-  var maskCount = 0;
-  var shadingCount = 0;
-
-  exports.SVGGraphics = SVGGraphics =
-  /*#__PURE__*/
-  function () {
-    function SVGGraphics(commonObjs, objs, forceDataSchema) {
-      _classCallCheck(this, SVGGraphics);
-
-      this.svgFactory = new _display_utils.DOMSVGFactory();
-      this.current = new SVGExtraState();
-      this.transformMatrix = _util.IDENTITY_MATRIX;
-      this.transformStack = [];
-      this.extraStack = [];
-      this.commonObjs = commonObjs;
-      this.objs = objs;
-      this.pendingClip = null;
-      this.pendingEOFill = false;
-      this.embedFonts = false;
-      this.embeddedFonts = Object.create(null);
-      this.cssStyle = null;
-      this.forceDataSchema = !!forceDataSchema;
-      this._operatorIdMapping = [];
-
-      for (var op in _util.OPS) {
-        this._operatorIdMapping[_util.OPS[op]] = op;
-      }
-    }
-
-    _createClass(SVGGraphics, [{
-      key: "save",
-      value: function save() {
-        this.transformStack.push(this.transformMatrix);
-        var old = this.current;
-        this.extraStack.push(old);
-        this.current = old.clone();
-      }
-    }, {
-      key: "restore",
-      value: function restore() {
-        this.transformMatrix = this.transformStack.pop();
-        this.current = this.extraStack.pop();
-        this.pendingClip = null;
-        this.tgrp = null;
-      }
-    }, {
-      key: "group",
-      value: function group(items) {
-        this.save();
-        this.executeOpTree(items);
-        this.restore();
-      }
-    }, {
-      key: "loadDependencies",
-      value: function loadDependencies(operatorList) {
-        var _this = this;
-
-        var fnArray = operatorList.fnArray;
-        var argsArray = operatorList.argsArray;
-
-        for (var i = 0, ii = fnArray.length; i < ii; i++) {
-          if (fnArray[i] !== _util.OPS.dependency) {
-            continue;
-          }
-
-          var _iteratorNormalCompletion2 = true;
-          var _didIteratorError2 = false;
-          var _iteratorError2 = undefined;
-
-          try {
-            var _loop = function _loop() {
-              var obj = _step2.value;
-              var objsPool = obj.startsWith('g_') ? _this.commonObjs : _this.objs;
-              var promise = new Promise(function (resolve) {
-                objsPool.get(obj, resolve);
-              });
-
-              _this.current.dependencies.push(promise);
-            };
-
-            for (var _iterator2 = argsArray[i][Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
-              _loop();
-            }
-          } catch (err) {
-            _didIteratorError2 = true;
-            _iteratorError2 = err;
-          } finally {
-            try {
-              if (!_iteratorNormalCompletion2 && _iterator2["return"] != null) {
-                _iterator2["return"]();
-              }
-            } finally {
-              if (_didIteratorError2) {
-                throw _iteratorError2;
-              }
-            }
-          }
-        }
-
-        return Promise.all(this.current.dependencies);
-      }
-    }, {
-      key: "transform",
-      value: function transform(a, b, c, d, e, f) {
-        var transformMatrix = [a, b, c, d, e, f];
-        this.transformMatrix = _util.Util.transform(this.transformMatrix, transformMatrix);
-        this.tgrp = null;
-      }
-    }, {
-      key: "getSVG",
-      value: function getSVG(operatorList, viewport) {
-        var _this2 = this;
-
-        this.viewport = viewport;
-
-        var svgElement = this._initialize(viewport);
-
-        return this.loadDependencies(operatorList).then(function () {
-          _this2.transformMatrix = _util.IDENTITY_MATRIX;
-
-          _this2.executeOpTree(_this2.convertOpList(operatorList));
-
-          return svgElement;
-        });
-      }
-    }, {
-      key: "convertOpList",
-      value: function convertOpList(operatorList) {
-        var operatorIdMapping = this._operatorIdMapping;
-        var argsArray = operatorList.argsArray;
-        var fnArray = operatorList.fnArray;
-        var opList = [];
-
-        for (var i = 0, ii = fnArray.length; i < ii; i++) {
-          var fnId = fnArray[i];
-          opList.push({
-            'fnId': fnId,
-            'fn': operatorIdMapping[fnId],
-            'args': argsArray[i]
-          });
-        }
-
-        return opListToTree(opList);
-      }
-    }, {
-      key: "executeOpTree",
-      value: function executeOpTree(opTree) {
-        var _iteratorNormalCompletion3 = true;
-        var _didIteratorError3 = false;
-        var _iteratorError3 = undefined;
-
-        try {
-          for (var _iterator3 = opTree[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
-            var opTreeElement = _step3.value;
-            var fn = opTreeElement.fn;
-            var fnId = opTreeElement.fnId;
-            var args = opTreeElement.args;
-
-            switch (fnId | 0) {
-              case _util.OPS.beginText:
-                this.beginText();
-                break;
-
-              case _util.OPS.dependency:
-                break;
-
-              case _util.OPS.setLeading:
-                this.setLeading(args);
-                break;
-
-              case _util.OPS.setLeadingMoveText:
-                this.setLeadingMoveText(args[0], args[1]);
-                break;
-
-              case _util.OPS.setFont:
-                this.setFont(args);
-                break;
-
-              case _util.OPS.showText:
-                this.showText(args[0]);
-                break;
-
-              case _util.OPS.showSpacedText:
-                this.showText(args[0]);
-                break;
-
-              case _util.OPS.endText:
-                this.endText();
-                break;
-
-              case _util.OPS.moveText:
-                this.moveText(args[0], args[1]);
-                break;
-
-              case _util.OPS.setCharSpacing:
-                this.setCharSpacing(args[0]);
-                break;
-
-              case _util.OPS.setWordSpacing:
-                this.setWordSpacing(args[0]);
-                break;
-
-              case _util.OPS.setHScale:
-                this.setHScale(args[0]);
-                break;
-
-              case _util.OPS.setTextMatrix:
-                this.setTextMatrix(args[0], args[1], args[2], args[3], args[4], args[5]);
-                break;
-
-              case _util.OPS.setTextRise:
-                this.setTextRise(args[0]);
-                break;
-
-              case _util.OPS.setTextRenderingMode:
-                this.setTextRenderingMode(args[0]);
-                break;
-
-              case _util.OPS.setLineWidth:
-                this.setLineWidth(args[0]);
-                break;
-
-              case _util.OPS.setLineJoin:
-                this.setLineJoin(args[0]);
-                break;
-
-              case _util.OPS.setLineCap:
-                this.setLineCap(args[0]);
-                break;
-
-              case _util.OPS.setMiterLimit:
-                this.setMiterLimit(args[0]);
-                break;
-
-              case _util.OPS.setFillRGBColor:
-                this.setFillRGBColor(args[0], args[1], args[2]);
-                break;
-
-              case _util.OPS.setStrokeRGBColor:
-                this.setStrokeRGBColor(args[0], args[1], args[2]);
-                break;
-
-              case _util.OPS.setStrokeColorN:
-                this.setStrokeColorN(args);
-                break;
-
-              case _util.OPS.setFillColorN:
-                this.setFillColorN(args);
-                break;
-
-              case _util.OPS.shadingFill:
-                this.shadingFill(args[0]);
-                break;
-
-              case _util.OPS.setDash:
-                this.setDash(args[0], args[1]);
-                break;
-
-              case _util.OPS.setRenderingIntent:
-                this.setRenderingIntent(args[0]);
-                break;
-
-              case _util.OPS.setFlatness:
-                this.setFlatness(args[0]);
-                break;
-
-              case _util.OPS.setGState:
-                this.setGState(args[0]);
-                break;
-
-              case _util.OPS.fill:
-                this.fill();
-                break;
-
-              case _util.OPS.eoFill:
-                this.eoFill();
-                break;
-
-              case _util.OPS.stroke:
-                this.stroke();
-                break;
-
-              case _util.OPS.fillStroke:
-                this.fillStroke();
-                break;
-
-              case _util.OPS.eoFillStroke:
-                this.eoFillStroke();
-                break;
-
-              case _util.OPS.clip:
-                this.clip('nonzero');
-                break;
-
-              case _util.OPS.eoClip:
-                this.clip('evenodd');
-                break;
-
-              case _util.OPS.paintSolidColorImageMask:
-                this.paintSolidColorImageMask();
-                break;
-
-              case _util.OPS.paintJpegXObject:
-                this.paintJpegXObject(args[0], args[1], args[2]);
-                break;
-
-              case _util.OPS.paintImageXObject:
-                this.paintImageXObject(args[0]);
-                break;
-
-              case _util.OPS.paintInlineImageXObject:
-                this.paintInlineImageXObject(args[0]);
-                break;
-
-              case _util.OPS.paintImageMaskXObject:
-                this.paintImageMaskXObject(args[0]);
-                break;
-
-              case _util.OPS.paintFormXObjectBegin:
-                this.paintFormXObjectBegin(args[0], args[1]);
-                break;
-
-              case _util.OPS.paintFormXObjectEnd:
-                this.paintFormXObjectEnd();
-                break;
-
-              case _util.OPS.closePath:
-                this.closePath();
-                break;
-
-              case _util.OPS.closeStroke:
-                this.closeStroke();
-                break;
-
-              case _util.OPS.closeFillStroke:
-                this.closeFillStroke();
-                break;
-
-              case _util.OPS.closeEOFillStroke:
-                this.closeEOFillStroke();
-                break;
-
-              case _util.OPS.nextLine:
-                this.nextLine();
-                break;
-
-              case _util.OPS.transform:
-                this.transform(args[0], args[1], args[2], args[3], args[4], args[5]);
-                break;
-
-              case _util.OPS.constructPath:
-                this.constructPath(args[0], args[1]);
-                break;
-
-              case _util.OPS.endPath:
-                this.endPath();
-                break;
-
-              case 92:
-                this.group(opTreeElement.items);
-                break;
-
-              default:
-                (0, _util.warn)("Unimplemented operator ".concat(fn));
-                break;
-            }
-          }
-        } catch (err) {
-          _didIteratorError3 = true;
-          _iteratorError3 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion3 && _iterator3["return"] != null) {
-              _iterator3["return"]();
-            }
-          } finally {
-            if (_didIteratorError3) {
-              throw _iteratorError3;
-            }
-          }
-        }
-      }
-    }, {
-      key: "setWordSpacing",
-      value: function setWordSpacing(wordSpacing) {
-        this.current.wordSpacing = wordSpacing;
-      }
-    }, {
-      key: "setCharSpacing",
-      value: function setCharSpacing(charSpacing) {
-        this.current.charSpacing = charSpacing;
-      }
-    }, {
-      key: "nextLine",
-      value: function nextLine() {
-        this.moveText(0, this.current.leading);
-      }
-    }, {
-      key: "setTextMatrix",
-      value: function setTextMatrix(a, b, c, d, e, f) {
-        var current = this.current;
-        current.textMatrix = current.lineMatrix = [a, b, c, d, e, f];
-        current.textMatrixScale = Math.sqrt(a * a + b * b);
-        current.x = current.lineX = 0;
-        current.y = current.lineY = 0;
-        current.xcoords = [];
-        current.tspan = this.svgFactory.createElement('svg:tspan');
-        current.tspan.setAttributeNS(null, 'font-family', current.fontFamily);
-        current.tspan.setAttributeNS(null, 'font-size', "".concat(pf(current.fontSize), "px"));
-        current.tspan.setAttributeNS(null, 'y', pf(-current.y));
-        current.txtElement = this.svgFactory.createElement('svg:text');
-        current.txtElement.appendChild(current.tspan);
-      }
-    }, {
-      key: "beginText",
-      value: function beginText() {
-        var current = this.current;
-        current.x = current.lineX = 0;
-        current.y = current.lineY = 0;
-        current.textMatrix = _util.IDENTITY_MATRIX;
-        current.lineMatrix = _util.IDENTITY_MATRIX;
-        current.textMatrixScale = 1;
-        current.tspan = this.svgFactory.createElement('svg:tspan');
-        current.txtElement = this.svgFactory.createElement('svg:text');
-        current.txtgrp = this.svgFactory.createElement('svg:g');
-        current.xcoords = [];
-      }
-    }, {
-      key: "moveText",
-      value: function moveText(x, y) {
-        var current = this.current;
-        current.x = current.lineX += x;
-        current.y = current.lineY += y;
-        current.xcoords = [];
-        current.tspan = this.svgFactory.createElement('svg:tspan');
-        current.tspan.setAttributeNS(null, 'font-family', current.fontFamily);
-        current.tspan.setAttributeNS(null, 'font-size', "".concat(pf(current.fontSize), "px"));
-        current.tspan.setAttributeNS(null, 'y', pf(-current.y));
-      }
-    }, {
-      key: "showText",
-      value: function showText(glyphs) {
-        var current = this.current;
-        var font = current.font;
-        var fontSize = current.fontSize;
-
-        if (fontSize === 0) {
-          return;
-        }
-
-        var charSpacing = current.charSpacing;
-        var wordSpacing = current.wordSpacing;
-        var fontDirection = current.fontDirection;
-        var textHScale = current.textHScale * fontDirection;
-        var vertical = font.vertical;
-        var widthAdvanceScale = fontSize * current.fontMatrix[0];
-        var x = 0;
-        var _iteratorNormalCompletion4 = true;
-        var _didIteratorError4 = false;
-        var _iteratorError4 = undefined;
-
-        try {
-          for (var _iterator4 = glyphs[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
-            var glyph = _step4.value;
-
-            if (glyph === null) {
-              x += fontDirection * wordSpacing;
-              continue;
-            } else if ((0, _util.isNum)(glyph)) {
-              x += -glyph * fontSize * 0.001;
-              continue;
-            }
-
-            var width = glyph.width;
-            var character = glyph.fontChar;
-            var spacing = (glyph.isSpace ? wordSpacing : 0) + charSpacing;
-            var charWidth = width * widthAdvanceScale + spacing * fontDirection;
-
-            if (!glyph.isInFont && !font.missingFile) {
-              x += charWidth;
-              continue;
-            }
-
-            current.xcoords.push(current.x + x * textHScale);
-            current.tspan.textContent += character;
-            x += charWidth;
-          }
-        } catch (err) {
-          _didIteratorError4 = true;
-          _iteratorError4 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion4 && _iterator4["return"] != null) {
-              _iterator4["return"]();
-            }
-          } finally {
-            if (_didIteratorError4) {
-              throw _iteratorError4;
-            }
-          }
-        }
-
-        if (vertical) {
-          current.y -= x * textHScale;
-        } else {
-          current.x += x * textHScale;
-        }
-
-        current.tspan.setAttributeNS(null, 'x', current.xcoords.map(pf).join(' '));
-        current.tspan.setAttributeNS(null, 'y', pf(-current.y));
-        current.tspan.setAttributeNS(null, 'font-family', current.fontFamily);
-        current.tspan.setAttributeNS(null, 'font-size', "".concat(pf(current.fontSize), "px"));
-
-        if (current.fontStyle !== SVG_DEFAULTS.fontStyle) {
-          current.tspan.setAttributeNS(null, 'font-style', current.fontStyle);
-        }
-
-        if (current.fontWeight !== SVG_DEFAULTS.fontWeight) {
-          current.tspan.setAttributeNS(null, 'font-weight', current.fontWeight);
-        }
-
-        var fillStrokeMode = current.textRenderingMode & _util.TextRenderingMode.FILL_STROKE_MASK;
-
-        if (fillStrokeMode === _util.TextRenderingMode.FILL || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
-          if (current.fillColor !== SVG_DEFAULTS.fillColor) {
-            current.tspan.setAttributeNS(null, 'fill', current.fillColor);
-          }
-
-          if (current.fillAlpha < 1) {
-            current.tspan.setAttributeNS(null, 'fill-opacity', current.fillAlpha);
-          }
-        } else if (current.textRenderingMode === _util.TextRenderingMode.ADD_TO_PATH) {
-          current.tspan.setAttributeNS(null, 'fill', 'transparent');
-        } else {
-          current.tspan.setAttributeNS(null, 'fill', 'none');
-        }
-
-        if (fillStrokeMode === _util.TextRenderingMode.STROKE || fillStrokeMode === _util.TextRenderingMode.FILL_STROKE) {
-          var lineWidthScale = 1 / (current.textMatrixScale || 1);
-
-          this._setStrokeAttributes(current.tspan, lineWidthScale);
-        }
-
-        var textMatrix = current.textMatrix;
-
-        if (current.textRise !== 0) {
-          textMatrix = textMatrix.slice();
-          textMatrix[5] += current.textRise;
-        }
-
-        current.txtElement.setAttributeNS(null, 'transform', "".concat(pm(textMatrix), " scale(1, -1)"));
-        current.txtElement.setAttributeNS(XML_NS, 'xml:space', 'preserve');
-        current.txtElement.appendChild(current.tspan);
-        current.txtgrp.appendChild(current.txtElement);
-
-        this._ensureTransformGroup().appendChild(current.txtElement);
-      }
-    }, {
-      key: "setLeadingMoveText",
-      value: function setLeadingMoveText(x, y) {
-        this.setLeading(-y);
-        this.moveText(x, y);
-      }
-    }, {
-      key: "addFontStyle",
-      value: function addFontStyle(fontObj) {
-        if (!this.cssStyle) {
-          this.cssStyle = this.svgFactory.createElement('svg:style');
-          this.cssStyle.setAttributeNS(null, 'type', 'text/css');
-          this.defs.appendChild(this.cssStyle);
-        }
-
-        var url = (0, _util.createObjectURL)(fontObj.data, fontObj.mimetype, this.forceDataSchema);
-        this.cssStyle.textContent += "@font-face { font-family: \"".concat(fontObj.loadedName, "\";") + " src: url(".concat(url, "); }\n");
-      }
-    }, {
-      key: "setFont",
-      value: function setFont(details) {
-        var current = this.current;
-        var fontObj = this.commonObjs.get(details[0]);
-        var size = details[1];
-        current.font = fontObj;
-
-        if (this.embedFonts && fontObj.data && !this.embeddedFonts[fontObj.loadedName]) {
-          this.addFontStyle(fontObj);
-          this.embeddedFonts[fontObj.loadedName] = fontObj;
-        }
-
-        current.fontMatrix = fontObj.fontMatrix ? fontObj.fontMatrix : _util.FONT_IDENTITY_MATRIX;
-        var bold = fontObj.black ? fontObj.bold ? 'bolder' : 'bold' : fontObj.bold ? 'bold' : 'normal';
-        var italic = fontObj.italic ? 'italic' : 'normal';
-
-        if (size < 0) {
-          size = -size;
-          current.fontDirection = -1;
-        } else {
-          current.fontDirection = 1;
-        }
-
-        current.fontSize = size;
-        current.fontFamily = fontObj.loadedName;
-        current.fontWeight = bold;
-        current.fontStyle = italic;
-        current.tspan = this.svgFactory.createElement('svg:tspan');
-        current.tspan.setAttributeNS(null, 'y', pf(-current.y));
-        current.xcoords = [];
-      }
-    }, {
-      key: "endText",
-      value: function endText() {
-        var current = this.current;
-
-        if (current.textRenderingMode & _util.TextRenderingMode.ADD_TO_PATH_FLAG && current.txtElement && current.txtElement.hasChildNodes()) {
-          current.element = current.txtElement;
-          this.clip('nonzero');
-          this.endPath();
-        }
-      }
-    }, {
-      key: "setLineWidth",
-      value: function setLineWidth(width) {
-        if (width > 0) {
-          this.current.lineWidth = width;
-        }
-      }
-    }, {
-      key: "setLineCap",
-      value: function setLineCap(style) {
-        this.current.lineCap = LINE_CAP_STYLES[style];
-      }
-    }, {
-      key: "setLineJoin",
-      value: function setLineJoin(style) {
-        this.current.lineJoin = LINE_JOIN_STYLES[style];
-      }
-    }, {
-      key: "setMiterLimit",
-      value: function setMiterLimit(limit) {
-        this.current.miterLimit = limit;
-      }
-    }, {
-      key: "setStrokeAlpha",
-      value: function setStrokeAlpha(strokeAlpha) {
-        this.current.strokeAlpha = strokeAlpha;
-      }
-    }, {
-      key: "setStrokeRGBColor",
-      value: function setStrokeRGBColor(r, g, b) {
-        this.current.strokeColor = _util.Util.makeCssRgb(r, g, b);
-      }
-    }, {
-      key: "setFillAlpha",
-      value: function setFillAlpha(fillAlpha) {
-        this.current.fillAlpha = fillAlpha;
-      }
-    }, {
-      key: "setFillRGBColor",
-      value: function setFillRGBColor(r, g, b) {
-        this.current.fillColor = _util.Util.makeCssRgb(r, g, b);
-        this.current.tspan = this.svgFactory.createElement('svg:tspan');
-        this.current.xcoords = [];
-      }
-    }, {
-      key: "setStrokeColorN",
-      value: function setStrokeColorN(args) {
-        this.current.strokeColor = this._makeColorN_Pattern(args);
-      }
-    }, {
-      key: "setFillColorN",
-      value: function setFillColorN(args) {
-        this.current.fillColor = this._makeColorN_Pattern(args);
-      }
-    }, {
-      key: "shadingFill",
-      value: function shadingFill(args) {
-        var width = this.viewport.width;
-        var height = this.viewport.height;
-
-        var inv = _util.Util.inverseTransform(this.transformMatrix);
-
-        var bl = _util.Util.applyTransform([0, 0], inv);
-
-        var br = _util.Util.applyTransform([0, height], inv);
-
-        var ul = _util.Util.applyTransform([width, 0], inv);
-
-        var ur = _util.Util.applyTransform([width, height], inv);
-
-        var x0 = Math.min(bl[0], br[0], ul[0], ur[0]);
-        var y0 = Math.min(bl[1], br[1], ul[1], ur[1]);
-        var x1 = Math.max(bl[0], br[0], ul[0], ur[0]);
-        var y1 = Math.max(bl[1], br[1], ul[1], ur[1]);
-        var rect = this.svgFactory.createElement('svg:rect');
-        rect.setAttributeNS(null, 'x', x0);
-        rect.setAttributeNS(null, 'y', y0);
-        rect.setAttributeNS(null, 'width', x1 - x0);
-        rect.setAttributeNS(null, 'height', y1 - y0);
-        rect.setAttributeNS(null, 'fill', this._makeShadingPattern(args));
-
-        this._ensureTransformGroup().appendChild(rect);
-      }
-    }, {
-      key: "_makeColorN_Pattern",
-      value: function _makeColorN_Pattern(args) {
-        if (args[0] === 'TilingPattern') {
-          return this._makeTilingPattern(args);
-        }
-
-        return this._makeShadingPattern(args);
-      }
-    }, {
-      key: "_makeTilingPattern",
-      value: function _makeTilingPattern(args) {
-        var color = args[1];
-        var operatorList = args[2];
-        var matrix = args[3] || _util.IDENTITY_MATRIX;
-
-        var _args$ = _slicedToArray(args[4], 4),
-            x0 = _args$[0],
-            y0 = _args$[1],
-            x1 = _args$[2],
-            y1 = _args$[3];
-
-        var xstep = args[5];
-        var ystep = args[6];
-        var paintType = args[7];
-        var tilingId = "shading".concat(shadingCount++);
-
-        var _Util$applyTransform = _util.Util.applyTransform([x0, y0], matrix),
-            _Util$applyTransform2 = _slicedToArray(_Util$applyTransform, 2),
-            tx0 = _Util$applyTransform2[0],
-            ty0 = _Util$applyTransform2[1];
-
-        var _Util$applyTransform3 = _util.Util.applyTransform([x1, y1], matrix),
-            _Util$applyTransform4 = _slicedToArray(_Util$applyTransform3, 2),
-            tx1 = _Util$applyTransform4[0],
-            ty1 = _Util$applyTransform4[1];
-
-        var _Util$singularValueDe = _util.Util.singularValueDecompose2dScale(matrix),
-            _Util$singularValueDe2 = _slicedToArray(_Util$singularValueDe, 2),
-            xscale = _Util$singularValueDe2[0],
-            yscale = _Util$singularValueDe2[1];
-
-        var txstep = xstep * xscale;
-        var tystep = ystep * yscale;
-        var tiling = this.svgFactory.createElement('svg:pattern');
-        tiling.setAttributeNS(null, 'id', tilingId);
-        tiling.setAttributeNS(null, 'patternUnits', 'userSpaceOnUse');
-        tiling.setAttributeNS(null, 'width', txstep);
-        tiling.setAttributeNS(null, 'height', tystep);
-        tiling.setAttributeNS(null, 'x', "".concat(tx0));
-        tiling.setAttributeNS(null, 'y', "".concat(ty0));
-        var svg = this.svg;
-        var transformMatrix = this.transformMatrix;
-        var fillColor = this.current.fillColor;
-        var strokeColor = this.current.strokeColor;
-        var bbox = this.svgFactory.create(tx1 - tx0, ty1 - ty0);
-        this.svg = bbox;
-        this.transformMatrix = matrix;
-
-        if (paintType === 2) {
-          var cssColor = _util.Util.makeCssRgb.apply(_util.Util, _toConsumableArray(color));
-
-          this.current.fillColor = cssColor;
-          this.current.strokeColor = cssColor;
-        }
-
-        this.executeOpTree(this.convertOpList(operatorList));
-        this.svg = svg;
-        this.transformMatrix = transformMatrix;
-        this.current.fillColor = fillColor;
-        this.current.strokeColor = strokeColor;
-        tiling.appendChild(bbox.childNodes[0]);
-        this.defs.appendChild(tiling);
-        return "url(#".concat(tilingId, ")");
-      }
-    }, {
-      key: "_makeShadingPattern",
-      value: function _makeShadingPattern(args) {
-        switch (args[0]) {
-          case 'RadialAxial':
-            var shadingId = "shading".concat(shadingCount++);
-            var colorStops = args[2];
-            var gradient;
-
-            switch (args[1]) {
-              case 'axial':
-                var point0 = args[3];
-                var point1 = args[4];
-                gradient = this.svgFactory.createElement('svg:linearGradient');
-                gradient.setAttributeNS(null, 'id', shadingId);
-                gradient.setAttributeNS(null, 'gradientUnits', 'userSpaceOnUse');
-                gradient.setAttributeNS(null, 'x1', point0[0]);
-                gradient.setAttributeNS(null, 'y1', point0[1]);
-                gradient.setAttributeNS(null, 'x2', point1[0]);
-                gradient.setAttributeNS(null, 'y2', point1[1]);
-                break;
-
-              case 'radial':
-                var focalPoint = args[3];
-                var circlePoint = args[4];
-                var focalRadius = args[5];
-                var circleRadius = args[6];
-                gradient = this.svgFactory.createElement('svg:radialGradient');
-                gradient.setAttributeNS(null, 'id', shadingId);
-                gradient.setAttributeNS(null, 'gradientUnits', 'userSpaceOnUse');
-                gradient.setAttributeNS(null, 'cx', circlePoint[0]);
-                gradient.setAttributeNS(null, 'cy', circlePoint[1]);
-                gradient.setAttributeNS(null, 'r', circleRadius);
-                gradient.setAttributeNS(null, 'fx', focalPoint[0]);
-                gradient.setAttributeNS(null, 'fy', focalPoint[1]);
-                gradient.setAttributeNS(null, 'fr', focalRadius);
-                break;
-
-              default:
-                throw new Error("Unknown RadialAxial type: ".concat(args[1]));
-            }
-
-            var _iteratorNormalCompletion5 = true;
-            var _didIteratorError5 = false;
-            var _iteratorError5 = undefined;
-
-            try {
-              for (var _iterator5 = colorStops[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
-                var colorStop = _step5.value;
-                var stop = this.svgFactory.createElement('svg:stop');
-                stop.setAttributeNS(null, 'offset', colorStop[0]);
-                stop.setAttributeNS(null, 'stop-color', colorStop[1]);
-                gradient.appendChild(stop);
-              }
-            } catch (err) {
-              _didIteratorError5 = true;
-              _iteratorError5 = err;
-            } finally {
-              try {
-                if (!_iteratorNormalCompletion5 && _iterator5["return"] != null) {
-                  _iterator5["return"]();
-                }
-              } finally {
-                if (_didIteratorError5) {
-                  throw _iteratorError5;
-                }
-              }
-            }
-
-            this.defs.appendChild(gradient);
-            return "url(#".concat(shadingId, ")");
-
-          case 'Mesh':
-            (0, _util.warn)('Unimplemented pattern Mesh');
-            return null;
-
-          case 'Dummy':
-            return 'hotpink';
-
-          default:
-            throw new Error("Unknown IR type: ".concat(args[0]));
-        }
-      }
-    }, {
-      key: "setDash",
-      value: function setDash(dashArray, dashPhase) {
-        this.current.dashArray = dashArray;
-        this.current.dashPhase = dashPhase;
-      }
-    }, {
-      key: "constructPath",
-      value: function constructPath(ops, args) {
-        var current = this.current;
-        var x = current.x,
-            y = current.y;
-        var d = [];
-        var j = 0;
-        var _iteratorNormalCompletion6 = true;
-        var _didIteratorError6 = false;
-        var _iteratorError6 = undefined;
-
-        try {
-          for (var _iterator6 = ops[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
-            var op = _step6.value;
-
-            switch (op | 0) {
-              case _util.OPS.rectangle:
-                x = args[j++];
-                y = args[j++];
-                var width = args[j++];
-                var height = args[j++];
-                var xw = x + width;
-                var yh = y + height;
-                d.push('M', pf(x), pf(y), 'L', pf(xw), pf(y), 'L', pf(xw), pf(yh), 'L', pf(x), pf(yh), 'Z');
-                break;
-
-              case _util.OPS.moveTo:
-                x = args[j++];
-                y = args[j++];
-                d.push('M', pf(x), pf(y));
-                break;
-
-              case _util.OPS.lineTo:
-                x = args[j++];
-                y = args[j++];
-                d.push('L', pf(x), pf(y));
-                break;
-
-              case _util.OPS.curveTo:
-                x = args[j + 4];
-                y = args[j + 5];
-                d.push('C', pf(args[j]), pf(args[j + 1]), pf(args[j + 2]), pf(args[j + 3]), pf(x), pf(y));
-                j += 6;
-                break;
-
-              case _util.OPS.curveTo2:
-                x = args[j + 2];
-                y = args[j + 3];
-                d.push('C', pf(x), pf(y), pf(args[j]), pf(args[j + 1]), pf(args[j + 2]), pf(args[j + 3]));
-                j += 4;
-                break;
-
-              case _util.OPS.curveTo3:
-                x = args[j + 2];
-                y = args[j + 3];
-                d.push('C', pf(args[j]), pf(args[j + 1]), pf(x), pf(y), pf(x), pf(y));
-                j += 4;
-                break;
-
-              case _util.OPS.closePath:
-                d.push('Z');
-                break;
-            }
-          }
-        } catch (err) {
-          _didIteratorError6 = true;
-          _iteratorError6 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion6 && _iterator6["return"] != null) {
-              _iterator6["return"]();
-            }
-          } finally {
-            if (_didIteratorError6) {
-              throw _iteratorError6;
-            }
-          }
-        }
-
-        d = d.join(' ');
-
-        if (current.path && ops.length > 0 && ops[0] !== _util.OPS.rectangle && ops[0] !== _util.OPS.moveTo) {
-          d = current.path.getAttributeNS(null, 'd') + d;
-        } else {
-          current.path = this.svgFactory.createElement('svg:path');
-
-          this._ensureTransformGroup().appendChild(current.path);
-        }
-
-        current.path.setAttributeNS(null, 'd', d);
-        current.path.setAttributeNS(null, 'fill', 'none');
-        current.element = current.path;
-        current.setCurrentPoint(x, y);
-      }
-    }, {
-      key: "endPath",
-      value: function endPath() {
-        var current = this.current;
-        current.path = null;
-
-        if (!this.pendingClip) {
-          return;
-        }
-
-        if (!current.element) {
-          this.pendingClip = null;
-          return;
-        }
-
-        var clipId = "clippath".concat(clipCount++);
-        var clipPath = this.svgFactory.createElement('svg:clipPath');
-        clipPath.setAttributeNS(null, 'id', clipId);
-        clipPath.setAttributeNS(null, 'transform', pm(this.transformMatrix));
-        var clipElement = current.element.cloneNode(true);
-
-        if (this.pendingClip === 'evenodd') {
-          clipElement.setAttributeNS(null, 'clip-rule', 'evenodd');
-        } else {
-          clipElement.setAttributeNS(null, 'clip-rule', 'nonzero');
-        }
-
-        this.pendingClip = null;
-        clipPath.appendChild(clipElement);
-        this.defs.appendChild(clipPath);
-
-        if (current.activeClipUrl) {
-          current.clipGroup = null;
-          this.extraStack.forEach(function (prev) {
-            prev.clipGroup = null;
-          });
-          clipPath.setAttributeNS(null, 'clip-path', current.activeClipUrl);
-        }
-
-        current.activeClipUrl = "url(#".concat(clipId, ")");
-        this.tgrp = null;
-      }
-    }, {
-      key: "clip",
-      value: function clip(type) {
-        this.pendingClip = type;
-      }
-    }, {
-      key: "closePath",
-      value: function closePath() {
-        var current = this.current;
-
-        if (current.path) {
-          var d = "".concat(current.path.getAttributeNS(null, 'd'), "Z");
-          current.path.setAttributeNS(null, 'd', d);
-        }
-      }
-    }, {
-      key: "setLeading",
-      value: function setLeading(leading) {
-        this.current.leading = -leading;
-      }
-    }, {
-      key: "setTextRise",
-      value: function setTextRise(textRise) {
-        this.current.textRise = textRise;
-      }
-    }, {
-      key: "setTextRenderingMode",
-      value: function setTextRenderingMode(textRenderingMode) {
-        this.current.textRenderingMode = textRenderingMode;
-      }
-    }, {
-      key: "setHScale",
-      value: function setHScale(scale) {
-        this.current.textHScale = scale / 100;
-      }
-    }, {
-      key: "setRenderingIntent",
-      value: function setRenderingIntent(intent) {}
-    }, {
-      key: "setFlatness",
-      value: function setFlatness(flatness) {}
-    }, {
-      key: "setGState",
-      value: function setGState(states) {
-        var _iteratorNormalCompletion7 = true;
-        var _didIteratorError7 = false;
-        var _iteratorError7 = undefined;
-
-        try {
-          for (var _iterator7 = states[Symbol.iterator](), _step7; !(_iteratorNormalCompletion7 = (_step7 = _iterator7.next()).done); _iteratorNormalCompletion7 = true) {
-            var _step7$value = _slicedToArray(_step7.value, 2),
-                key = _step7$value[0],
-                value = _step7$value[1];
-
-            switch (key) {
-              case 'LW':
-                this.setLineWidth(value);
-                break;
-
-              case 'LC':
-                this.setLineCap(value);
-                break;
-
-              case 'LJ':
-                this.setLineJoin(value);
-                break;
-
-              case 'ML':
-                this.setMiterLimit(value);
-                break;
-
-              case 'D':
-                this.setDash(value[0], value[1]);
-                break;
-
-              case 'RI':
-                this.setRenderingIntent(value);
-                break;
-
-              case 'FL':
-                this.setFlatness(value);
-                break;
-
-              case 'Font':
-                this.setFont(value);
-                break;
-
-              case 'CA':
-                this.setStrokeAlpha(value);
-                break;
-
-              case 'ca':
-                this.setFillAlpha(value);
-                break;
-
-              default:
-                (0, _util.warn)("Unimplemented graphic state operator ".concat(key));
-                break;
-            }
-          }
-        } catch (err) {
-          _didIteratorError7 = true;
-          _iteratorError7 = err;
-        } finally {
-          try {
-            if (!_iteratorNormalCompletion7 && _iterator7["return"] != null) {
-              _iterator7["return"]();
-            }
-          } finally {
-            if (_didIteratorError7) {
-              throw _iteratorError7;
-            }
-          }
-        }
-      }
-    }, {
-      key: "fill",
-      value: function fill() {
-        var current = this.current;
-
-        if (current.element) {
-          current.element.setAttributeNS(null, 'fill', current.fillColor);
-          current.element.setAttributeNS(null, 'fill-opacity', current.fillAlpha);
-          this.endPath();
-        }
-      }
-    }, {
-      key: "stroke",
-      value: function stroke() {
-        var current = this.current;
-
-        if (current.element) {
-          this._setStrokeAttributes(current.element);
-
-          current.element.setAttributeNS(null, 'fill', 'none');
-          this.endPath();
-        }
-      }
-    }, {
-      key: "_setStrokeAttributes",
-      value: function _setStrokeAttributes(element) {
-        var lineWidthScale = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
-        var current = this.current;
-        var dashArray = current.dashArray;
-
-        if (lineWidthScale !== 1 && dashArray.length > 0) {
-          dashArray = dashArray.map(function (value) {
-            return lineWidthScale * value;
-          });
-        }
-
-        element.setAttributeNS(null, 'stroke', current.strokeColor);
-        element.setAttributeNS(null, 'stroke-opacity', current.strokeAlpha);
-        element.setAttributeNS(null, 'stroke-miterlimit', pf(current.miterLimit));
-        element.setAttributeNS(null, 'stroke-linecap', current.lineCap);
-        element.setAttributeNS(null, 'stroke-linejoin', current.lineJoin);
-        element.setAttributeNS(null, 'stroke-width', pf(lineWidthScale * current.lineWidth) + 'px');
-        element.setAttributeNS(null, 'stroke-dasharray', dashArray.map(pf).join(' '));
-        element.setAttributeNS(null, 'stroke-dashoffset', pf(lineWidthScale * current.dashPhase) + 'px');
-      }
-    }, {
-      key: "eoFill",
-      value: function eoFill() {
-        if (this.current.element) {
-          this.current.element.setAttributeNS(null, 'fill-rule', 'evenodd');
-        }
-
-        this.fill();
-      }
-    }, {
-      key: "fillStroke",
-      value: function fillStroke() {
-        this.stroke();
-        this.fill();
-      }
-    }, {
-      key: "eoFillStroke",
-      value: function eoFillStroke() {
-        if (this.current.element) {
-          this.current.element.setAttributeNS(null, 'fill-rule', 'evenodd');
-        }
-
-        this.fillStroke();
-      }
-    }, {
-      key: "closeStroke",
-      value: function closeStroke() {
-        this.closePath();
-        this.stroke();
-      }
-    }, {
-      key: "closeFillStroke",
-      value: function closeFillStroke() {
-        this.closePath();
-        this.fillStroke();
-      }
-    }, {
-      key: "closeEOFillStroke",
-      value: function closeEOFillStroke() {
-        this.closePath();
-        this.eoFillStroke();
-      }
-    }, {
-      key: "paintSolidColorImageMask",
-      value: function paintSolidColorImageMask() {
-        var rect = this.svgFactory.createElement('svg:rect');
-        rect.setAttributeNS(null, 'x', '0');
-        rect.setAttributeNS(null, 'y', '0');
-        rect.setAttributeNS(null, 'width', '1px');
-        rect.setAttributeNS(null, 'height', '1px');
-        rect.setAttributeNS(null, 'fill', this.current.fillColor);
-
-        this._ensureTransformGroup().appendChild(rect);
-      }
-    }, {
-      key: "paintJpegXObject",
-      value: function paintJpegXObject(objId, w, h) {
-        var imgObj = this.objs.get(objId);
-        var imgEl = this.svgFactory.createElement('svg:image');
-        imgEl.setAttributeNS(XLINK_NS, 'xlink:href', imgObj.src);
-        imgEl.setAttributeNS(null, 'width', pf(w));
-        imgEl.setAttributeNS(null, 'height', pf(h));
-        imgEl.setAttributeNS(null, 'x', '0');
-        imgEl.setAttributeNS(null, 'y', pf(-h));
-        imgEl.setAttributeNS(null, 'transform', "scale(".concat(pf(1 / w), " ").concat(pf(-1 / h), ")"));
-
-        this._ensureTransformGroup().appendChild(imgEl);
-      }
-    }, {
-      key: "paintImageXObject",
-      value: function paintImageXObject(objId) {
-        var imgData = this.objs.get(objId);
-
-        if (!imgData) {
-          (0, _util.warn)("Dependent image with object ID ".concat(objId, " is not ready yet"));
-          return;
-        }
-
-        this.paintInlineImageXObject(imgData);
-      }
-    }, {
-      key: "paintInlineImageXObject",
-      value: function paintInlineImageXObject(imgData, mask) {
-        var width = imgData.width;
-        var height = imgData.height;
-        var imgSrc = convertImgDataToPng(imgData, this.forceDataSchema, !!mask);
-        var cliprect = this.svgFactory.createElement('svg:rect');
-        cliprect.setAttributeNS(null, 'x', '0');
-        cliprect.setAttributeNS(null, 'y', '0');
-        cliprect.setAttributeNS(null, 'width', pf(width));
-        cliprect.setAttributeNS(null, 'height', pf(height));
-        this.current.element = cliprect;
-        this.clip('nonzero');
-        var imgEl = this.svgFactory.createElement('svg:image');
-        imgEl.setAttributeNS(XLINK_NS, 'xlink:href', imgSrc);
-        imgEl.setAttributeNS(null, 'x', '0');
-        imgEl.setAttributeNS(null, 'y', pf(-height));
-        imgEl.setAttributeNS(null, 'width', pf(width) + 'px');
-        imgEl.setAttributeNS(null, 'height', pf(height) + 'px');
-        imgEl.setAttributeNS(null, 'transform', "scale(".concat(pf(1 / width), " ").concat(pf(-1 / height), ")"));
-
-        if (mask) {
-          mask.appendChild(imgEl);
-        } else {
-          this._ensureTransformGroup().appendChild(imgEl);
-        }
-      }
-    }, {
-      key: "paintImageMaskXObject",
-      value: function paintImageMaskXObject(imgData) {
-        var current = this.current;
-        var width = imgData.width;
-        var height = imgData.height;
-        var fillColor = current.fillColor;
-        current.maskId = "mask".concat(maskCount++);
-        var mask = this.svgFactory.createElement('svg:mask');
-        mask.setAttributeNS(null, 'id', current.maskId);
-        var rect = this.svgFactory.createElement('svg:rect');
-        rect.setAttributeNS(null, 'x', '0');
-        rect.setAttributeNS(null, 'y', '0');
-        rect.setAttributeNS(null, 'width', pf(width));
-        rect.setAttributeNS(null, 'height', pf(height));
-        rect.setAttributeNS(null, 'fill', fillColor);
-        rect.setAttributeNS(null, 'mask', "url(#".concat(current.maskId, ")"));
-        this.defs.appendChild(mask);
-
-        this._ensureTransformGroup().appendChild(rect);
-
-        this.paintInlineImageXObject(imgData, mask);
-      }
-    }, {
-      key: "paintFormXObjectBegin",
-      value: function paintFormXObjectBegin(matrix, bbox) {
-        if (Array.isArray(matrix) && matrix.length === 6) {
-          this.transform(matrix[0], matrix[1], matrix[2], matrix[3], matrix[4], matrix[5]);
-        }
-
-        if (bbox) {
-          var width = bbox[2] - bbox[0];
-          var height = bbox[3] - bbox[1];
-          var cliprect = this.svgFactory.createElement('svg:rect');
-          cliprect.setAttributeNS(null, 'x', bbox[0]);
-          cliprect.setAttributeNS(null, 'y', bbox[1]);
-          cliprect.setAttributeNS(null, 'width', pf(width));
-          cliprect.setAttributeNS(null, 'height', pf(height));
-          this.current.element = cliprect;
-          this.clip('nonzero');
-          this.endPath();
-        }
-      }
-    }, {
-      key: "paintFormXObjectEnd",
-      value: function paintFormXObjectEnd() {}
-    }, {
-      key: "_initialize",
-      value: function _initialize(viewport) {
-        var svg = this.svgFactory.create(viewport.width, viewport.height);
-        var definitions = this.svgFactory.createElement('svg:defs');
-        svg.appendChild(definitions);
-        this.defs = definitions;
-        var rootGroup = this.svgFactory.createElement('svg:g');
-        rootGroup.setAttributeNS(null, 'transform', pm(viewport.transform));
-        svg.appendChild(rootGroup);
-        this.svg = rootGroup;
-        return svg;
-      }
-    }, {
-      key: "_ensureClipGroup",
-      value: function _ensureClipGroup() {
-        if (!this.current.clipGroup) {
-          var clipGroup = this.svgFactory.createElement('svg:g');
-          clipGroup.setAttributeNS(null, 'clip-path', this.current.activeClipUrl);
-          this.svg.appendChild(clipGroup);
-          this.current.clipGroup = clipGroup;
-        }
-
-        return this.current.clipGroup;
-      }
-    }, {
-      key: "_ensureTransformGroup",
-      value: function _ensureTransformGroup() {
-        if (!this.tgrp) {
-          this.tgrp = this.svgFactory.createElement('svg:g');
-          this.tgrp.setAttributeNS(null, 'transform', pm(this.transformMatrix));
-
-          if (this.current.activeClipUrl) {
-            this._ensureClipGroup().appendChild(this.tgrp);
-          } else {
-            this.svg.appendChild(this.tgrp);
-          }
-        }
-
-        return this.tgrp;
-      }
-    }]);
-
-    return SVGGraphics;
-  }();
-}
-
-/***/ }),
-/* 165 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.PDFNetworkStream = void 0;
-
-var _regenerator = _interopRequireDefault(__w_pdfjs_require__(148));
-
-var _util = __w_pdfjs_require__(1);
-
-var _network_utils = __w_pdfjs_require__(166);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-;
-var OK_RESPONSE = 200;
-var PARTIAL_CONTENT_RESPONSE = 206;
-
-function getArrayBuffer(xhr) {
-  var data = xhr.response;
-
-  if (typeof data !== 'string') {
-    return data;
-  }
-
-  var array = (0, _util.stringToBytes)(data);
-  return array.buffer;
-}
-
-var NetworkManager =
-/*#__PURE__*/
-function () {
-  function NetworkManager(url, args) {
-    _classCallCheck(this, NetworkManager);
-
-    this.url = url;
-    args = args || {};
-    this.isHttp = /^https?:/i.test(url);
-    this.httpHeaders = this.isHttp && args.httpHeaders || {};
-    this.withCredentials = args.withCredentials || false;
-
-    this.getXhr = args.getXhr || function NetworkManager_getXhr() {
-      return new XMLHttpRequest();
-    };
-
-    this.currXhrId = 0;
-    this.pendingRequests = Object.create(null);
-  }
-
-  _createClass(NetworkManager, [{
-    key: "requestRange",
-    value: function requestRange(begin, end, listeners) {
-      var args = {
-        begin: begin,
-        end: end
-      };
-
-      for (var prop in listeners) {
-        args[prop] = listeners[prop];
-      }
-
-      return this.request(args);
-    }
-  }, {
-    key: "requestFull",
-    value: function requestFull(listeners) {
-      return this.request(listeners);
-    }
-  }, {
-    key: "request",
-    value: function request(args) {
-      var xhr = this.getXhr();
-      var xhrId = this.currXhrId++;
-      var pendingRequest = this.pendingRequests[xhrId] = {
-        xhr: xhr
-      };
-      xhr.open('GET', this.url);
-      xhr.withCredentials = this.withCredentials;
-
-      for (var property in this.httpHeaders) {
-        var value = this.httpHeaders[property];
-
-        if (typeof value === 'undefined') {
-          continue;
-        }
-
-        xhr.setRequestHeader(property, value);
-      }
-
-      if (this.isHttp && 'begin' in args && 'end' in args) {
-        xhr.setRequestHeader('Range', "bytes=".concat(args.begin, "-").concat(args.end - 1));
-        pendingRequest.expectedStatus = PARTIAL_CONTENT_RESPONSE;
-      } else {
-        pendingRequest.expectedStatus = OK_RESPONSE;
-      }
-
-      xhr.responseType = 'arraybuffer';
-
-      if (args.onError) {
-        xhr.onerror = function (evt) {
-          args.onError(xhr.status);
-        };
-      }
-
-      xhr.onreadystatechange = this.onStateChange.bind(this, xhrId);
-      xhr.onprogress = this.onProgress.bind(this, xhrId);
-      pendingRequest.onHeadersReceived = args.onHeadersReceived;
-      pendingRequest.onDone = args.onDone;
-      pendingRequest.onError = args.onError;
-      pendingRequest.onProgress = args.onProgress;
-      xhr.send(null);
-      return xhrId;
-    }
-  }, {
-    key: "onProgress",
-    value: function onProgress(xhrId, evt) {
-      var pendingRequest = this.pendingRequests[xhrId];
-
-      if (!pendingRequest) {
-        return;
-      }
-
-      if (pendingRequest.onProgress) {
-        pendingRequest.onProgress(evt);
-      }
-    }
-  }, {
-    key: "onStateChange",
-    value: function onStateChange(xhrId, evt) {
-      var pendingRequest = this.pendingRequests[xhrId];
-
-      if (!pendingRequest) {
-        return;
-      }
-
-      var xhr = pendingRequest.xhr;
-
-      if (xhr.readyState >= 2 && pendingRequest.onHeadersReceived) {
-        pendingRequest.onHeadersReceived();
-        delete pendingRequest.onHeadersReceived;
-      }
-
-      if (xhr.readyState !== 4) {
-        return;
-      }
-
-      if (!(xhrId in this.pendingRequests)) {
-        return;
-      }
-
-      delete this.pendingRequests[xhrId];
-
-      if (xhr.status === 0 && this.isHttp) {
-        if (pendingRequest.onError) {
-          pendingRequest.onError(xhr.status);
-        }
-
-        return;
-      }
-
-      var xhrStatus = xhr.status || OK_RESPONSE;
-      var ok_response_on_range_request = xhrStatus === OK_RESPONSE && pendingRequest.expectedStatus === PARTIAL_CONTENT_RESPONSE;
-
-      if (!ok_response_on_range_request && xhrStatus !== pendingRequest.expectedStatus) {
-        if (pendingRequest.onError) {
-          pendingRequest.onError(xhr.status);
-        }
-
-        return;
-      }
-
-      var chunk = getArrayBuffer(xhr);
-
-      if (xhrStatus === PARTIAL_CONTENT_RESPONSE) {
-        var rangeHeader = xhr.getResponseHeader('Content-Range');
-        var matches = /bytes (\d+)-(\d+)\/(\d+)/.exec(rangeHeader);
-        pendingRequest.onDone({
-          begin: parseInt(matches[1], 10),
-          chunk: chunk
-        });
-      } else if (chunk) {
-        pendingRequest.onDone({
-          begin: 0,
-          chunk: chunk
-        });
-      } else if (pendingRequest.onError) {
-        pendingRequest.onError(xhr.status);
-      }
-    }
-  }, {
-    key: "hasPendingRequests",
-    value: function hasPendingRequests() {
-      for (var xhrId in this.pendingRequests) {
-        return true;
-      }
-
-      return false;
-    }
-  }, {
-    key: "getRequestXhr",
-    value: function getRequestXhr(xhrId) {
-      return this.pendingRequests[xhrId].xhr;
-    }
-  }, {
-    key: "isPendingRequest",
-    value: function isPendingRequest(xhrId) {
-      return xhrId in this.pendingRequests;
-    }
-  }, {
-    key: "abortAllRequests",
-    value: function abortAllRequests() {
-      for (var xhrId in this.pendingRequests) {
-        this.abortRequest(xhrId | 0);
-      }
-    }
-  }, {
-    key: "abortRequest",
-    value: function abortRequest(xhrId) {
-      var xhr = this.pendingRequests[xhrId].xhr;
-      delete this.pendingRequests[xhrId];
-      xhr.abort();
-    }
-  }]);
-
-  return NetworkManager;
-}();
-
-var PDFNetworkStream =
-/*#__PURE__*/
-function () {
-  function PDFNetworkStream(source) {
-    _classCallCheck(this, PDFNetworkStream);
-
-    this._source = source;
-    this._manager = new NetworkManager(source.url, {
-      httpHeaders: source.httpHeaders,
-      withCredentials: source.withCredentials
-    });
-    this._rangeChunkSize = source.rangeChunkSize;
-    this._fullRequestReader = null;
-    this._rangeRequestReaders = [];
-  }
-
-  _createClass(PDFNetworkStream, [{
-    key: "_onRangeRequestReaderClosed",
-    value: function _onRangeRequestReaderClosed(reader) {
-      var i = this._rangeRequestReaders.indexOf(reader);
-
-      if (i >= 0) {
-        this._rangeRequestReaders.splice(i, 1);
-      }
-    }
-  }, {
-    key: "getFullReader",
-    value: function getFullReader() {
-      (0, _util.assert)(!this._fullRequestReader);
-      this._fullRequestReader = new PDFNetworkStreamFullRequestReader(this._manager, this._source);
-      return this._fullRequestReader;
-    }
-  }, {
-    key: "getRangeReader",
-    value: function getRangeReader(begin, end) {
-      var reader = new PDFNetworkStreamRangeRequestReader(this._manager, begin, end);
-      reader.onClosed = this._onRangeRequestReaderClosed.bind(this);
-
-      this._rangeRequestReaders.push(reader);
-
-      return reader;
-    }
-  }, {
-    key: "cancelAllRequests",
-    value: function cancelAllRequests(reason) {
-      if (this._fullRequestReader) {
-        this._fullRequestReader.cancel(reason);
-      }
-
-      var readers = this._rangeRequestReaders.slice(0);
-
-      readers.forEach(function (reader) {
-        reader.cancel(reason);
-      });
-    }
-  }]);
-
-  return PDFNetworkStream;
-}();
-
-exports.PDFNetworkStream = PDFNetworkStream;
-
-var PDFNetworkStreamFullRequestReader =
-/*#__PURE__*/
-function () {
-  function PDFNetworkStreamFullRequestReader(manager, source) {
-    _classCallCheck(this, PDFNetworkStreamFullRequestReader);
-
-    this._manager = manager;
-    var args = {
-      onHeadersReceived: this._onHeadersReceived.bind(this),
-      onDone: this._onDone.bind(this),
-      onError: this._onError.bind(this),
-      onProgress: this._onProgress.bind(this)
-    };
-    this._url = source.url;
-    this._fullRequestId = manager.requestFull(args);
-    this._headersReceivedCapability = (0, _util.createPromiseCapability)();
-    this._disableRange = source.disableRange || false;
-    this._contentLength = source.length;
-    this._rangeChunkSize = source.rangeChunkSize;
-
-    if (!this._rangeChunkSize && !this._disableRange) {
-      this._disableRange = true;
-    }
-
-    this._isStreamingSupported = false;
-    this._isRangeSupported = false;
-    this._cachedChunks = [];
-    this._requests = [];
-    this._done = false;
-    this._storedError = undefined;
-    this._filename = null;
-    this.onProgress = null;
-  }
-
-  _createClass(PDFNetworkStreamFullRequestReader, [{
-    key: "_onHeadersReceived",
-    value: function _onHeadersReceived() {
-      var fullRequestXhrId = this._fullRequestId;
-
-      var fullRequestXhr = this._manager.getRequestXhr(fullRequestXhrId);
-
-      var getResponseHeader = function getResponseHeader(name) {
-        return fullRequestXhr.getResponseHeader(name);
-      };
-
-      var _validateRangeRequest = (0, _network_utils.validateRangeRequestCapabilities)({
-        getResponseHeader: getResponseHeader,
-        isHttp: this._manager.isHttp,
-        rangeChunkSize: this._rangeChunkSize,
-        disableRange: this._disableRange
-      }),
-          allowRangeRequests = _validateRangeRequest.allowRangeRequests,
-          suggestedLength = _validateRangeRequest.suggestedLength;
-
-      if (allowRangeRequests) {
-        this._isRangeSupported = true;
-      }
-
-      this._contentLength = suggestedLength || this._contentLength;
-      this._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader);
-
-      if (this._isRangeSupported) {
-        this._manager.abortRequest(fullRequestXhrId);
-      }
-
-      this._headersReceivedCapability.resolve();
-    }
-  }, {
-    key: "_onDone",
-    value: function _onDone(args) {
-      if (args) {
-        if (this._requests.length > 0) {
-          var requestCapability = this._requests.shift();
-
-          requestCapability.resolve({
-            value: args.chunk,
-            done: false
-          });
-        } else {
-          this._cachedChunks.push(args.chunk);
-        }
-      }
-
-      this._done = true;
-
-      if (this._cachedChunks.length > 0) {
-        return;
-      }
-
-      this._requests.forEach(function (requestCapability) {
-        requestCapability.resolve({
-          value: undefined,
-          done: true
-        });
-      });
-
-      this._requests = [];
-    }
-  }, {
-    key: "_onError",
-    value: function _onError(status) {
-      var url = this._url;
-      var exception = (0, _network_utils.createResponseStatusError)(status, url);
-      this._storedError = exception;
-
-      this._headersReceivedCapability.reject(exception);
-
-      this._requests.forEach(function (requestCapability) {
-        requestCapability.reject(exception);
-      });
-
-      this._requests = [];
-      this._cachedChunks = [];
-    }
-  }, {
-    key: "_onProgress",
-    value: function _onProgress(data) {
-      if (this.onProgress) {
-        this.onProgress({
-          loaded: data.loaded,
-          total: data.lengthComputable ? data.total : this._contentLength
-        });
-      }
-    }
-  }, {
-    key: "read",
-    value: function () {
-      var _read = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator["default"].mark(function _callee() {
-        var chunk, requestCapability;
-        return _regenerator["default"].wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                if (!this._storedError) {
-                  _context.next = 2;
-                  break;
-                }
-
-                throw this._storedError;
-
-              case 2:
-                if (!(this._cachedChunks.length > 0)) {
-                  _context.next = 5;
-                  break;
-                }
-
-                chunk = this._cachedChunks.shift();
-                return _context.abrupt("return", {
-                  value: chunk,
-                  done: false
-                });
-
-              case 5:
-                if (!this._done) {
-                  _context.next = 7;
-                  break;
-                }
-
-                return _context.abrupt("return", {
-                  value: undefined,
-                  done: true
-                });
-
-              case 7:
-                requestCapability = (0, _util.createPromiseCapability)();
-
-                this._requests.push(requestCapability);
-
-                return _context.abrupt("return", requestCapability.promise);
-
-              case 10:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this);
-      }));
-
-      function read() {
-        return _read.apply(this, arguments);
-      }
-
-      return read;
-    }()
-  }, {
-    key: "cancel",
-    value: function cancel(reason) {
-      this._done = true;
-
-      this._headersReceivedCapability.reject(reason);
-
-      this._requests.forEach(function (requestCapability) {
-        requestCapability.resolve({
-          value: undefined,
-          done: true
-        });
-      });
-
-      this._requests = [];
-
-      if (this._manager.isPendingRequest(this._fullRequestId)) {
-        this._manager.abortRequest(this._fullRequestId);
-      }
-
-      this._fullRequestReader = null;
-    }
-  }, {
-    key: "filename",
-    get: function get() {
-      return this._filename;
-    }
-  }, {
-    key: "isRangeSupported",
-    get: function get() {
-      return this._isRangeSupported;
-    }
-  }, {
-    key: "isStreamingSupported",
-    get: function get() {
-      return this._isStreamingSupported;
-    }
-  }, {
-    key: "contentLength",
-    get: function get() {
-      return this._contentLength;
-    }
-  }, {
-    key: "headersReady",
-    get: function get() {
-      return this._headersReceivedCapability.promise;
-    }
-  }]);
-
-  return PDFNetworkStreamFullRequestReader;
-}();
-
-var PDFNetworkStreamRangeRequestReader =
-/*#__PURE__*/
-function () {
-  function PDFNetworkStreamRangeRequestReader(manager, begin, end) {
-    _classCallCheck(this, PDFNetworkStreamRangeRequestReader);
-
-    this._manager = manager;
-    var args = {
-      onDone: this._onDone.bind(this),
-      onProgress: this._onProgress.bind(this)
-    };
-    this._requestId = manager.requestRange(begin, end, args);
-    this._requests = [];
-    this._queuedChunk = null;
-    this._done = false;
-    this.onProgress = null;
-    this.onClosed = null;
-  }
-
-  _createClass(PDFNetworkStreamRangeRequestReader, [{
-    key: "_close",
-    value: function _close() {
-      if (this.onClosed) {
-        this.onClosed(this);
-      }
-    }
-  }, {
-    key: "_onDone",
-    value: function _onDone(data) {
-      var chunk = data.chunk;
-
-      if (this._requests.length > 0) {
-        var requestCapability = this._requests.shift();
-
-        requestCapability.resolve({
-          value: chunk,
-          done: false
-        });
-      } else {
-        this._queuedChunk = chunk;
-      }
-
-      this._done = true;
-
-      this._requests.forEach(function (requestCapability) {
-        requestCapability.resolve({
-          value: undefined,
-          done: true
-        });
-      });
-
-      this._requests = [];
-
-      this._close();
-    }
-  }, {
-    key: "_onProgress",
-    value: function _onProgress(evt) {
-      if (!this.isStreamingSupported && this.onProgress) {
-        this.onProgress({
-          loaded: evt.loaded
-        });
-      }
-    }
-  }, {
-    key: "read",
-    value: function () {
-      var _read2 = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator["default"].mark(function _callee2() {
-        var chunk, requestCapability;
-        return _regenerator["default"].wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                if (!(this._queuedChunk !== null)) {
-                  _context2.next = 4;
-                  break;
-                }
-
-                chunk = this._queuedChunk;
-                this._queuedChunk = null;
-                return _context2.abrupt("return", {
-                  value: chunk,
-                  done: false
-                });
-
-              case 4:
-                if (!this._done) {
-                  _context2.next = 6;
-                  break;
-                }
-
-                return _context2.abrupt("return", {
-                  value: undefined,
-                  done: true
-                });
-
-              case 6:
-                requestCapability = (0, _util.createPromiseCapability)();
-
-                this._requests.push(requestCapability);
-
-                return _context2.abrupt("return", requestCapability.promise);
-
-              case 9:
-              case "end":
-                return _context2.stop();
-            }
-          }
-        }, _callee2, this);
-      }));
-
-      function read() {
-        return _read2.apply(this, arguments);
-      }
-
-      return read;
-    }()
-  }, {
-    key: "cancel",
-    value: function cancel(reason) {
-      this._done = true;
-
-      this._requests.forEach(function (requestCapability) {
-        requestCapability.resolve({
-          value: undefined,
-          done: true
-        });
-      });
-
-      this._requests = [];
-
-      if (this._manager.isPendingRequest(this._requestId)) {
-        this._manager.abortRequest(this._requestId);
-      }
-
-      this._close();
-    }
-  }, {
-    key: "isStreamingSupported",
-    get: function get() {
-      return false;
-    }
-  }]);
-
-  return PDFNetworkStreamRangeRequestReader;
-}();
-
-/***/ }),
-/* 166 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createResponseStatusError = createResponseStatusError;
-exports.extractFilenameFromHeader = extractFilenameFromHeader;
-exports.validateRangeRequestCapabilities = validateRangeRequestCapabilities;
-exports.validateResponseStatus = validateResponseStatus;
-
-var _util = __w_pdfjs_require__(1);
-
-var _content_disposition = __w_pdfjs_require__(167);
-
-function validateRangeRequestCapabilities(_ref) {
-  var getResponseHeader = _ref.getResponseHeader,
-      isHttp = _ref.isHttp,
-      rangeChunkSize = _ref.rangeChunkSize,
-      disableRange = _ref.disableRange;
-  (0, _util.assert)(rangeChunkSize > 0, 'Range chunk size must be larger than zero');
-  var returnValues = {
-    allowRangeRequests: false,
-    suggestedLength: undefined
-  };
-  var length = parseInt(getResponseHeader('Content-Length'), 10);
-
-  if (!Number.isInteger(length)) {
-    return returnValues;
-  }
-
-  returnValues.suggestedLength = length;
-
-  if (length <= 2 * rangeChunkSize) {
-    return returnValues;
-  }
-
-  if (disableRange || !isHttp) {
-    return returnValues;
-  }
-
-  if (getResponseHeader('Accept-Ranges') !== 'bytes') {
-    return returnValues;
-  }
-
-  var contentEncoding = getResponseHeader('Content-Encoding') || 'identity';
-
-  if (contentEncoding !== 'identity') {
-    return returnValues;
-  }
-
-  returnValues.allowRangeRequests = true;
-  return returnValues;
-}
-
-function extractFilenameFromHeader(getResponseHeader) {
-  var contentDisposition = getResponseHeader('Content-Disposition');
-
-  if (contentDisposition) {
-    var filename = (0, _content_disposition.getFilenameFromContentDispositionHeader)(contentDisposition);
-
-    if (/\.pdf$/i.test(filename)) {
-      return filename;
-    }
-  }
-
-  return null;
-}
-
-function createResponseStatusError(status, url) {
-  if (status === 404 || status === 0 && /^file:/.test(url)) {
-    return new _util.MissingPDFException('Missing PDF "' + url + '".');
-  }
-
-  return new _util.UnexpectedResponseException('Unexpected server response (' + status + ') while retrieving PDF "' + url + '".', status);
-}
-
-function validateResponseStatus(status) {
-  return status === 200 || status === 206;
-}
-
-/***/ }),
-/* 167 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.getFilenameFromContentDispositionHeader = getFilenameFromContentDispositionHeader;
-
-function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
-
-function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
-
-function _iterableToArrayLimit(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
-
-function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
-
-function getFilenameFromContentDispositionHeader(contentDisposition) {
-  var needsEncodingFixup = true;
-  var tmp = toParamRegExp('filename\\*', 'i').exec(contentDisposition);
-
-  if (tmp) {
-    tmp = tmp[1];
-    var filename = rfc2616unquote(tmp);
-    filename = unescape(filename);
-    filename = rfc5987decode(filename);
-    filename = rfc2047decode(filename);
-    return fixupEncoding(filename);
-  }
-
-  tmp = rfc2231getparam(contentDisposition);
-
-  if (tmp) {
-    var _filename = rfc2047decode(tmp);
-
-    return fixupEncoding(_filename);
-  }
-
-  tmp = toParamRegExp('filename', 'i').exec(contentDisposition);
-
-  if (tmp) {
-    tmp = tmp[1];
-
-    var _filename2 = rfc2616unquote(tmp);
-
-    _filename2 = rfc2047decode(_filename2);
-    return fixupEncoding(_filename2);
-  }
-
-  function toParamRegExp(attributePattern, flags) {
-    return new RegExp('(?:^|;)\\s*' + attributePattern + '\\s*=\\s*' + '(' + '[^";\\s][^;\\s]*' + '|' + '"(?:[^"\\\\]|\\\\"?)+"?' + ')', flags);
-  }
-
-  function textdecode(encoding, value) {
-    if (encoding) {
-      if (!/^[\x00-\xFF]+$/.test(value)) {
-        return value;
-      }
-
-      try {
-        var decoder = new TextDecoder(encoding, {
-          fatal: true
-        });
-        var bytes = Array.from(value, function (ch) {
-          return ch.charCodeAt(0) & 0xFF;
-        });
-        value = decoder.decode(new Uint8Array(bytes));
-        needsEncodingFixup = false;
-      } catch (e) {
-        if (/^utf-?8$/i.test(encoding)) {
-          try {
-            value = decodeURIComponent(escape(value));
-            needsEncodingFixup = false;
-          } catch (err) {}
-        }
-      }
-    }
-
-    return value;
-  }
-
-  function fixupEncoding(value) {
-    if (needsEncodingFixup && /[\x80-\xff]/.test(value)) {
-      value = textdecode('utf-8', value);
-
-      if (needsEncodingFixup) {
-        value = textdecode('iso-8859-1', value);
-      }
-    }
-
-    return value;
-  }
-
-  function rfc2231getparam(contentDisposition) {
-    var matches = [],
-        match;
-    var iter = toParamRegExp('filename\\*((?!0\\d)\\d+)(\\*?)', 'ig');
-
-    while ((match = iter.exec(contentDisposition)) !== null) {
-      var _match = match,
-          _match2 = _slicedToArray(_match, 4),
-          n = _match2[1],
-          quot = _match2[2],
-          part = _match2[3];
-
-      n = parseInt(n, 10);
-
-      if (n in matches) {
-        if (n === 0) {
-          break;
-        }
-
-        continue;
-      }
-
-      matches[n] = [quot, part];
-    }
-
-    var parts = [];
-
-    for (var n = 0; n < matches.length; ++n) {
-      if (!(n in matches)) {
-        break;
-      }
-
-      var _matches$n = _slicedToArray(matches[n], 2),
-          quot = _matches$n[0],
-          part = _matches$n[1];
-
-      part = rfc2616unquote(part);
-
-      if (quot) {
-        part = unescape(part);
-
-        if (n === 0) {
-          part = rfc5987decode(part);
-        }
-      }
-
-      parts.push(part);
-    }
-
-    return parts.join('');
-  }
-
-  function rfc2616unquote(value) {
-    if (value.startsWith('"')) {
-      var parts = value.slice(1).split('\\"');
-
-      for (var i = 0; i < parts.length; ++i) {
-        var quotindex = parts[i].indexOf('"');
-
-        if (quotindex !== -1) {
-          parts[i] = parts[i].slice(0, quotindex);
-          parts.length = i + 1;
-        }
-
-        parts[i] = parts[i].replace(/\\(.)/g, '$1');
-      }
-
-      value = parts.join('"');
-    }
-
-    return value;
-  }
-
-  function rfc5987decode(extvalue) {
-    var encodingend = extvalue.indexOf('\'');
-
-    if (encodingend === -1) {
-      return extvalue;
-    }
-
-    var encoding = extvalue.slice(0, encodingend);
-    var langvalue = extvalue.slice(encodingend + 1);
-    var value = langvalue.replace(/^[^']*'/, '');
-    return textdecode(encoding, value);
-  }
-
-  function rfc2047decode(value) {
-    if (!value.startsWith('=?') || /[\x00-\x19\x80-\xff]/.test(value)) {
-      return value;
-    }
-
-    return value.replace(/=\?([\w-]*)\?([QqBb])\?((?:[^?]|\?(?!=))*)\?=/g, function (_, charset, encoding, text) {
-      if (encoding === 'q' || encoding === 'Q') {
-        text = text.replace(/_/g, ' ');
-        text = text.replace(/=([0-9a-fA-F]{2})/g, function (_, hex) {
-          return String.fromCharCode(parseInt(hex, 16));
-        });
-        return textdecode(charset, text);
-      }
-
-      try {
-        text = atob(text);
-      } catch (e) {}
-
-      return textdecode(charset, text);
-    });
-  }
-
-  return '';
-}
-
-/***/ }),
-/* 168 */
-/***/ (function(module, exports, __w_pdfjs_require__) {
-
-"use strict";
-
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.PDFFetchStream = void 0;
-
-var _regenerator = _interopRequireDefault(__w_pdfjs_require__(148));
-
-var _util = __w_pdfjs_require__(1);
-
-var _network_utils = __w_pdfjs_require__(166);
-
-function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
-
-function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { try { var info = gen[key](arg); var value = info.value; } catch (error) { reject(error); return; } if (info.done) { resolve(value); } else { Promise.resolve(value).then(_next, _throw); } }
-
-function _asyncToGenerator(fn) { return function () { var self = this, args = arguments; return new Promise(function (resolve, reject) { var gen = fn.apply(self, args); function _next(value) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); } function _throw(err) { asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); } _next(undefined); }); }; }
-
-function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
-
-function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
-
-function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
-
-function createFetchOptions(headers, withCredentials, abortController) {
-  return {
-    method: 'GET',
-    headers: headers,
-    signal: abortController && abortController.signal,
-    mode: 'cors',
-    credentials: withCredentials ? 'include' : 'same-origin',
-    redirect: 'follow'
-  };
-}
-
-var PDFFetchStream =
-/*#__PURE__*/
-function () {
-  function PDFFetchStream(source) {
-    _classCallCheck(this, PDFFetchStream);
-
-    this.source = source;
-    this.isHttp = /^https?:/i.test(source.url);
-    this.httpHeaders = this.isHttp && source.httpHeaders || {};
-    this._fullRequestReader = null;
-    this._rangeRequestReaders = [];
-  }
-
-  _createClass(PDFFetchStream, [{
-    key: "getFullReader",
-    value: function getFullReader() {
-      (0, _util.assert)(!this._fullRequestReader);
-      this._fullRequestReader = new PDFFetchStreamReader(this);
-      return this._fullRequestReader;
-    }
-  }, {
-    key: "getRangeReader",
-    value: function getRangeReader(begin, end) {
-      if (end <= this._progressiveDataLength) {
-        return null;
-      }
-
-      var reader = new PDFFetchStreamRangeReader(this, begin, end);
-
-      this._rangeRequestReaders.push(reader);
-
-      return reader;
-    }
-  }, {
-    key: "cancelAllRequests",
-    value: function cancelAllRequests(reason) {
-      if (this._fullRequestReader) {
-        this._fullRequestReader.cancel(reason);
-      }
-
-      var readers = this._rangeRequestReaders.slice(0);
-
-      readers.forEach(function (reader) {
-        reader.cancel(reason);
-      });
-    }
-  }, {
-    key: "_progressiveDataLength",
-    get: function get() {
-      return this._fullRequestReader ? this._fullRequestReader._loaded : 0;
-    }
-  }]);
-
-  return PDFFetchStream;
-}();
-
-exports.PDFFetchStream = PDFFetchStream;
-
-var PDFFetchStreamReader =
-/*#__PURE__*/
-function () {
-  function PDFFetchStreamReader(stream) {
-    var _this = this;
-
-    _classCallCheck(this, PDFFetchStreamReader);
-
-    this._stream = stream;
-    this._reader = null;
-    this._loaded = 0;
-    this._filename = null;
-    var source = stream.source;
-    this._withCredentials = source.withCredentials || false;
-    this._contentLength = source.length;
-    this._headersCapability = (0, _util.createPromiseCapability)();
-    this._disableRange = source.disableRange || false;
-    this._rangeChunkSize = source.rangeChunkSize;
-
-    if (!this._rangeChunkSize && !this._disableRange) {
-      this._disableRange = true;
-    }
-
-    if (typeof AbortController !== 'undefined') {
-      this._abortController = new AbortController();
-    }
-
-    this._isStreamingSupported = !source.disableStream;
-    this._isRangeSupported = !source.disableRange;
-    this._headers = new Headers();
-
-    for (var property in this._stream.httpHeaders) {
-      var value = this._stream.httpHeaders[property];
-
-      if (typeof value === 'undefined') {
-        continue;
-      }
-
-      this._headers.append(property, value);
-    }
-
-    var url = source.url;
-    fetch(url, createFetchOptions(this._headers, this._withCredentials, this._abortController)).then(function (response) {
-      if (!(0, _network_utils.validateResponseStatus)(response.status)) {
-        throw (0, _network_utils.createResponseStatusError)(response.status, url);
-      }
-
-      _this._reader = response.body.getReader();
-
-      _this._headersCapability.resolve();
-
-      var getResponseHeader = function getResponseHeader(name) {
-        return response.headers.get(name);
-      };
-
-      var _validateRangeRequest = (0, _network_utils.validateRangeRequestCapabilities)({
-        getResponseHeader: getResponseHeader,
-        isHttp: _this._stream.isHttp,
-        rangeChunkSize: _this._rangeChunkSize,
-        disableRange: _this._disableRange
-      }),
-          allowRangeRequests = _validateRangeRequest.allowRangeRequests,
-          suggestedLength = _validateRangeRequest.suggestedLength;
-
-      _this._isRangeSupported = allowRangeRequests;
-      _this._contentLength = suggestedLength || _this._contentLength;
-      _this._filename = (0, _network_utils.extractFilenameFromHeader)(getResponseHeader);
-
-      if (!_this._isStreamingSupported && _this._isRangeSupported) {
-        _this.cancel(new _util.AbortException('Streaming is disabled.'));
-      }
-    })["catch"](this._headersCapability.reject);
-    this.onProgress = null;
-  }
-
-  _createClass(PDFFetchStreamReader, [{
-    key: "read",
-    value: function () {
-      var _read = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator["default"].mark(function _callee() {
-        var _ref, value, done, buffer;
-
-        return _regenerator["default"].wrap(function _callee$(_context) {
-          while (1) {
-            switch (_context.prev = _context.next) {
-              case 0:
-                _context.next = 2;
-                return this._headersCapability.promise;
-
-              case 2:
-                _context.next = 4;
-                return this._reader.read();
-
-              case 4:
-                _ref = _context.sent;
-                value = _ref.value;
-                done = _ref.done;
-
-                if (!done) {
-                  _context.next = 9;
-                  break;
-                }
-
-                return _context.abrupt("return", {
-                  value: value,
-                  done: done
-                });
-
-              case 9:
-                this._loaded += value.byteLength;
-
-                if (this.onProgress) {
-                  this.onProgress({
-                    loaded: this._loaded,
-                    total: this._contentLength
-                  });
-                }
-
-                buffer = new Uint8Array(value).buffer;
-                return _context.abrupt("return", {
-                  value: buffer,
-                  done: false
-                });
-
-              case 13:
-              case "end":
-                return _context.stop();
-            }
-          }
-        }, _callee, this);
-      }));
-
-      function read() {
-        return _read.apply(this, arguments);
-      }
-
-      return read;
-    }()
-  }, {
-    key: "cancel",
-    value: function cancel(reason) {
-      if (this._reader) {
-        this._reader.cancel(reason);
-      }
-
-      if (this._abortController) {
-        this._abortController.abort();
-      }
-    }
-  }, {
-    key: "headersReady",
-    get: function get() {
-      return this._headersCapability.promise;
-    }
-  }, {
-    key: "filename",
-    get: function get() {
-      return this._filename;
-    }
-  }, {
-    key: "contentLength",
-    get: function get() {
-      return this._contentLength;
-    }
-  }, {
-    key: "isRangeSupported",
-    get: function get() {
-      return this._isRangeSupported;
-    }
-  }, {
-    key: "isStreamingSupported",
-    get: function get() {
-      return this._isStreamingSupported;
-    }
-  }]);
-
-  return PDFFetchStreamReader;
-}();
-
-var PDFFetchStreamRangeReader =
-/*#__PURE__*/
-function () {
-  function PDFFetchStreamRangeReader(stream, begin, end) {
-    var _this2 = this;
-
-    _classCallCheck(this, PDFFetchStreamRangeReader);
-
-    this._stream = stream;
-    this._reader = null;
-    this._loaded = 0;
-    var source = stream.source;
-    this._withCredentials = source.withCredentials || false;
-    this._readCapability = (0, _util.createPromiseCapability)();
-    this._isStreamingSupported = !source.disableStream;
-
-    if (typeof AbortController !== 'undefined') {
-      this._abortController = new AbortController();
-    }
-
-    this._headers = new Headers();
-
-    for (var property in this._stream.httpHeaders) {
-      var value = this._stream.httpHeaders[property];
-
-      if (typeof value === 'undefined') {
-        continue;
-      }
-
-      this._headers.append(property, value);
-    }
-
-    this._headers.append('Range', "bytes=".concat(begin, "-").concat(end - 1));
-
-    var url = source.url;
-    fetch(url, createFetchOptions(this._headers, this._withCredentials, this._abortController)).then(function (response) {
-      if (!(0, _network_utils.validateResponseStatus)(response.status)) {
-        throw (0, _network_utils.createResponseStatusError)(response.status, url);
-      }
-
-      _this2._readCapability.resolve();
-
-      _this2._reader = response.body.getReader();
-    })["catch"](this._readCapability.reject);
-    this.onProgress = null;
-  }
-
-  _createClass(PDFFetchStreamRangeReader, [{
-    key: "read",
-    value: function () {
-      var _read2 = _asyncToGenerator(
-      /*#__PURE__*/
-      _regenerator["default"].mark(function _callee2() {
-        var _ref2, value, done, buffer;
-
-        return _regenerator["default"].wrap(function _callee2$(_context2) {
-          while (1) {
-            switch (_context2.prev = _context2.next) {
-              case 0:
-                _context2.next = 2;
-                return this._readCapability.promise;
-
-              case 2:
-                _context2.next = 4;
-                return this._reader.read();
-
-              case 4:
-                _ref2 = _context2.sent;
-                value = _ref2.value;
-                done = _ref2.done;
-
-                if (!done) {
-                  _context2.next = 9;
-                  break;
-                }
-
-                return _context2.abrupt("return", {
-                  value: value,
-                  done: done
-                });
-
-              case 9:
-                this._loaded += value.byteLength;
-
-                if (this.onProgress) {
-                  this.onProgress({
-                    loaded: this._loaded
-                  });
-                }
-
-                buffer = new Uint8Array(value).buffer;
-                return _context2.abrupt("return", {
-                  value: buffer,
-                  done: false
-                });
-
-              case 13:
-              case "end":
-                return _context2.stop();
-            }
-          }
-        }, _callee2, this);
-      }));
-
-      function read() {
-        return _read2.apply(this, arguments);
-      }
-
-      return read;
-    }()
-  }, {
-    key: "cancel",
-    value: function cancel(reason) {
-      if (this._reader) {
-        this._reader.cancel(reason);
-      }
-
-      if (this._abortController) {
-        this._abortController.abort();
-      }
-    }
-  }, {
-    key: "isStreamingSupported",
-    get: function get() {
-      return this._isStreamingSupported;
-    }
-  }]);
-
-  return PDFFetchStreamRangeReader;
-}();
-
-/***/ })
-/******/ ]);
-});
-//# sourceMappingURL=pdf.js.map

services/web/frontend/js/vendor/libs/pdfjs-dist/patches/0001-misc-fix-handling-of-fetch-errors-backport.patch

@@ -1,67 +0,0 @@
-From 9826c6eb1ecd501ac3eb1e9d9a98a3e6edde3fd0 Mon Sep 17 00:00:00 2001
-From: Jakob Ackermann <jakob.ackermann@overleaf.com>
-Date: Mon, 5 Jul 2021 16:23:18 +0100
-Subject: [PATCH] [misc] fix handling of fetch errors (backport)
-
-Testing:
-- delete the pdf file while the initial request is inflight
-- delete the pdf file after the initial request has finished
----
- src/core/chunked_stream.js  | 8 +++-----
- src/display/fetch_stream.js | 2 +-
- 2 files changed, 4 insertions(+), 6 deletions(-)
-
-diff --git a/src/core/chunked_stream.js b/src/core/chunked_stream.js
-index 26a93f673..ab39037c1 100644
---- a/src/core/chunked_stream.js
-+++ b/src/core/chunked_stream.js
-@@ -307,7 +307,7 @@ class ChunkedStreamManager {
-     }
- 
-     let chunks = [], loaded = 0;
--    const promise = new Promise((resolve, reject) => {
-+    return new Promise((resolve, reject) => {
-       const readChunk = (chunk) => {
-         try {
-           if (!chunk.done) {
-@@ -328,14 +328,12 @@ class ChunkedStreamManager {
-         }
-       };
-       rangeReader.read().then(readChunk, reject);
--    });
--    promise.then((data) => {
-+    }).then((data) => {
-       if (this.aborted) {
-         return; // Ignoring any data after abort.
-       }
-       this.onReceiveData({ chunk: data, begin, });
-     });
--    // TODO check errors
-   }
- 
-   /**
-@@ -384,7 +382,7 @@ class ChunkedStreamManager {
-     for (const groupedChunk of groupedChunksToRequest) {
-       const begin = groupedChunk.beginChunk * this.chunkSize;
-       const end = Math.min(groupedChunk.endChunk * this.chunkSize, this.length);
--      this.sendRequest(begin, end);
-+      this.sendRequest(begin, end).catch(capability.reject);
-     }
- 
-     return capability.promise;
-diff --git a/src/display/fetch_stream.js b/src/display/fetch_stream.js
-index f70ed1d54..e736c9494 100644
---- a/src/display/fetch_stream.js
-+++ b/src/display/fetch_stream.js
-@@ -222,7 +222,7 @@ class PDFFetchStreamRangeReader {
-       }
-       this._readCapability.resolve();
-       this._reader = response.body.getReader();
--    });
-+    }).catch(this._readCapability.reject);
- 
-     this.onProgress = null;
-   }
--- 
-2.17.1
-

services/web/frontend/js/vendor/libs/pdfjs-dist/patches/0002-misc-do-not-bundle-NodeJS-stream-backend.patch

@@ -1,30 +0,0 @@
-From 6d118ec35e6e6f954938a485178748f1bb8bdd8a Mon Sep 17 00:00:00 2001
-From: Jakob Ackermann <jakob.ackermann@overleaf.com>
-Date: Mon, 5 Jul 2021 17:28:00 +0100
-Subject: [PATCH 2/2] [misc] do not bundle NodeJS stream backend
-
----
- src/pdf.js | 7 +------
- 1 file changed, 1 insertion(+), 6 deletions(-)
-
-diff --git a/src/pdf.js b/src/pdf.js
-index 4ccf2c1a7..7058c7a46 100644
---- a/src/pdf.js
-+++ b/src/pdf.js
-@@ -32,12 +32,7 @@ let pdfjsDisplayAPICompatibility = require('./display/api_compatibility.js');
- 
- if (typeof PDFJSDev === 'undefined' || PDFJSDev.test('GENERIC')) {
-   const isNodeJS = require('./shared/is_node.js');
--  if (isNodeJS()) {
--    let PDFNodeStream = require('./display/node_stream.js').PDFNodeStream;
--    pdfjsDisplayAPI.setPDFNetworkStreamFactory((params) => {
--      return new PDFNodeStream(params);
--    });
--  } else {
-+  if (!isNodeJS()) {
-     let PDFNetworkStream = require('./display/network.js').PDFNetworkStream;
-     let PDFFetchStream;
-     if (pdfjsDisplayDisplayUtils.isFetchSupported()) {
--- 
-2.17.1
-

services/web/frontend/stories/preview-logs-pane-entry.stories.js

@@ -1,134 +0,0 @@
-import PreviewLogsPaneEntry from '../js/features/preview/components/preview-logs-pane-entry.js'
-import Icon from '../js/shared/components/icon.js'
-
-export const EntryWithCompilerOutput = args => (
-  <PreviewLogsPaneEntry {...args} />
-)
-EntryWithCompilerOutput.args = {
-  title: 'PreviewLogsPaneEntry/bar/baz',
-  level: 'error',
-}
-
-export const EntryWithCompilerOutputAndHumanReadableHint = args => (
-  <PreviewLogsPaneEntry {...args} />
-)
-EntryWithCompilerOutputAndHumanReadableHint.args = {
-  level: 'error',
-  formattedContent: <SampleHumanReadableHintComponent />,
-  extraInfoURL:
-    'https://www.overleaf.com/learn/latex/Errors/Extra_alignment_tab_has_been_changed_to_%5Ccr',
-}
-
-export const EntryWithoutCompilerOutput = args => (
-  <PreviewLogsPaneEntry {...args} />
-)
-EntryWithoutCompilerOutput.args = {
-  level: 'error',
-  rawContent: null,
-}
-
-export const EntryWithoutSourceLocationLink = args => (
-  <PreviewLogsPaneEntry {...args} />
-)
-EntryWithoutSourceLocationLink.args = {
-  level: 'error',
-  showSourceLocationLink: false,
-}
-
-export const EntryWithLevelError = args => <PreviewLogsPaneEntry {...args} />
-EntryWithLevelError.args = {
-  level: 'error',
-}
-
-export const EntryWithLevelWarning = args => <PreviewLogsPaneEntry {...args} />
-EntryWithLevelWarning.args = {
-  level: 'warning',
-}
-
-export const EntryWithLevelTypesetting = args => (
-  <PreviewLogsPaneEntry {...args} />
-)
-EntryWithLevelTypesetting.args = {
-  level: 'typesetting',
-}
-
-export const EntryWithLevelRaw = args => <PreviewLogsPaneEntry {...args} />
-EntryWithLevelRaw.args = {
-  level: 'raw',
-}
-
-export const EntryWithLevelSuccess = args => <PreviewLogsPaneEntry {...args} />
-EntryWithLevelSuccess.args = {
-  level: 'success',
-}
-
-export const EntryWithButtonToClose = args => <PreviewLogsPaneEntry {...args} />
-EntryWithButtonToClose.args = {
-  level: 'error',
-  showCloseButton: true,
-  onClose: () => window.alert('You clicked "×"'),
-}
-
-export const EntryWithIcon = args => <PreviewLogsPaneEntry {...args} />
-EntryWithIcon.args = {
-  level: 'error',
-  headerIcon: <Icon type="taxi" />,
-}
-
-export const EntryWithBetaIcon = args => <PreviewLogsPaneEntry {...args} />
-EntryWithBetaIcon.args = {
-  level: 'typesetting',
-  headerIcon: <span className="beta-badge" />,
-}
-
-function SampleHumanReadableHintComponent() {
-  return (
-    <>
-      Human-readable hint to help LaTeX newbies. Supports <b>mark-up</b> for
-      e.g.{' '}
-      <a
-        target="_blank"
-        rel="noopener noreferrer"
-        href="https://www.overleaf.com/learn/latex/Errors/Extra_alignment_tab_has_been_changed_to_%5Ccr"
-      >
-        inline links
-      </a>
-      .
-    </>
-  )
-}
-
-export default {
-  title: 'Preview Logs / Entry',
-  component: PreviewLogsPaneEntry,
-  args: {
-    sourceLocation: {
-      file: 'foo/bar.tex',
-      line: 10,
-      column: 20,
-    },
-    headerTitle: 'Entry title',
-    rawContent: `
-The LaTeX compiler output
-  * With a lot of details
-
-Wrapped in an HTML <pre> element with
-      preformatted text which is to be presented exactly
-            as written in the HTML file
-
-                                              (whitespace included™)
-
-The text is typically rendered using a non-proportional ("monospace") font.
-
-LaTeX Font Info:    External font \`cmex10' loaded for size
-(Font)              <7> on input line 18.
-LaTeX Font Info:    External font \`cmex10' loaded for size
-(Font)              <5> on input line 18.
-! Undefined control sequence.
-<recently read> \\Zlpha
-
- main.tex, line 23
-
-`,
-  },
-}

services/web/frontend/stories/preview-logs-pane.stories.js

@@ -1,84 +0,0 @@
-import PreviewLogsPane from '../js/features/preview/components/preview-logs-pane'
-import { EditorProvider } from '../js/shared/context/editor-context'
-import { UserProvider } from '../js/shared/context/user-context'
-import useFetchMock from './hooks/use-fetch-mock'
-import { IdeProvider } from '../js/shared/context/ide-context'
-
-export const TimedOutError = args => {
-  useFetchMock(fetchMock => {
-    fetchMock.post('express:/event/:key', 202)
-  })
-
-  const ide = {
-    $scope: {
-      $watch: () => () => null,
-      project: {
-        owner: {
-          _id: window.user.id,
-        },
-        features: {
-          compileGroup: 'standard',
-        },
-      },
-    },
-  }
-
-  return (
-    <UserProvider>
-      <IdeProvider ide={ide}>
-        <EditorProvider settings={{}}>
-          <PreviewLogsPane {...args} />
-        </EditorProvider>
-      </IdeProvider>
-    </UserProvider>
-  )
-}
-TimedOutError.args = {
-  errors: {
-    timedout: {},
-  },
-}
-
-export const TimedOutErrorWithPriorityCompile = args => {
-  useFetchMock(fetchMock => {
-    fetchMock.post('express:/event/:key', 202)
-  })
-
-  const ide = {
-    $scope: {
-      $watch: () => () => null,
-      project: {
-        owner: {
-          _id: window.user.id,
-        },
-        features: {
-          compileGroup: 'priority',
-        },
-      },
-    },
-  }
-
-  return (
-    <UserProvider>
-      <IdeProvider ide={ide}>
-        <EditorProvider settings={{}}>
-          <PreviewLogsPane {...args} />
-        </EditorProvider>
-      </IdeProvider>
-    </UserProvider>
-  )
-}
-TimedOutErrorWithPriorityCompile.args = {
-  errors: {
-    timedout: {},
-  },
-}
-
-export default {
-  title: 'Preview Logs / Pane',
-  component: PreviewLogsPane,
-  argTypes: {
-    onLogEntryLocationClick: { action: 'log entry location' },
-    onClearCache: { action: 'clear cache' },
-  },
-}

services/web/test/frontend/features/pdf-preview/components/pdf-js-viewer.test.js

@@ -10,14 +10,6 @@ const example = pathToFileURL(
 ).toString()
 
 describe('<PdfJSViewer/>', function () {
-  beforeEach(function () {
-    window.showNewPdfPreview = true
-  })
-
-  afterEach(function () {
-    window.showNewPdfPreview = undefined
-  })
-
   it('loads all PDF pages', async function () {
     renderWithEditorContext(<PdfJsViewer url={example} />)
 

services/web/test/frontend/features/pdf-preview/components/pdf-preview.test.js

@@ -5,65 +5,16 @@ import { screen, fireEvent, waitFor, cleanup } from '@testing-library/react'
 import PdfPreview from '../../../../../frontend/js/features/pdf-preview/components/pdf-preview'
 import { renderWithEditorContext } from '../../../helpers/render-with-context'
 import nock from 'nock'
-import path from 'path'
-import fs from 'fs'
-import { cloneDeep } from 'lodash'
-
-const examplePDF = path.join(__dirname, '../fixtures/test-example.pdf')
-const corruptPDF = path.join(__dirname, '../fixtures/test-example-corrupt.pdf')
-
-const outputFiles = [
-  {
-    path: 'output.pdf',
-    build: '123',
-    url: '/build/output.pdf',
-    type: 'pdf',
-  },
-  {
-    path: 'output.bbl',
-    build: '123',
-    url: '/build/output.bbl',
-    type: 'bbl',
-  },
-  {
-    path: 'output.bib',
-    build: '123',
-    url: '/build/output.bib',
-    type: 'bib',
-  },
-  {
-    path: 'example.txt',
-    build: '123',
-    url: '/build/example.txt',
-    type: 'txt',
-  },
-  {
-    path: 'output.log',
-    build: '123',
-    url: '/build/output.log',
-    type: 'log',
-  },
-  {
-    path: 'output.blg',
-    build: '123',
-    url: '/build/output.blg',
-    type: 'blg',
-  },
-]
-
-const mockCompile = (delayPromise = Promise.resolve()) =>
-  fetchMock.post(
-    'express:/project/:projectId/compile',
-    delayPromise.then(() => ({
-      body: {
-        status: 'success',
-        clsiServerId: 'foo',
-        compileGroup: 'priority',
-        pdfDownloadDomain: 'https://clsi.test-overleaf.com',
-        outputFiles: cloneDeep(outputFiles),
-      },
-    }))
-  )
+import {
+  corruptPDF,
+  defaultFileResponses,
+  mockBuildFile,
+  mockClearCache,
+  mockCompile,
+  mockCompileError,
+  mockValidationProblems,
+  mockValidPdf,
+} from '../utils/mock-compile'
 
 const mockDelayed = fn => {
   let _resolve = null
@@ -74,83 +25,6 @@ const mockDelayed = fn => {
   return _resolve
 }
 
-const mockCompileError = status =>
-  fetchMock.post('express:/project/:projectId/compile', {
-    body: {
-      status,
-      clsiServerId: 'foo',
-      compileGroup: 'priority',
-    },
-  })
-
-const mockValidationProblems = validationProblems =>
-  fetchMock.post('express:/project/:projectId/compile', {
-    body: {
-      status: 'validation-problems',
-      validationProblems,
-      clsiServerId: 'foo',
-      compileGroup: 'priority',
-    },
-  })
-
-const mockClearCache = () =>
-  fetchMock.delete('express:/project/:projectId/output', 204)
-
-const mockValidPdf = () => {
-  nock('https://clsi.test-overleaf.com')
-    .get(/^\/build\/output\.pdf/)
-    .replyWithFile(200, examplePDF)
-}
-
-const defaultFileResponses = {
-  '/build/output.pdf': () => fs.createReadStream(examplePDF),
-  '/build/output.blg': 'This is BibTeX, Version 4.0', // FIXME
-  '/build/output.log': `
-The LaTeX compiler output
-  * With a lot of details
-
-Wrapped in an HTML <pre> element with
-      preformatted text which is to be presented exactly
-            as written in the HTML file
-
-                                              (whitespace included™)
-
-The text is typically rendered using a non-proportional ("monospace") font.
-
-LaTeX Font Info:    External font \`cmex10' loaded for size
-(Font)              <7> on input line 18.
-LaTeX Font Info:    External font \`cmex10' loaded for size
-(Font)              <5> on input line 18.
-! Undefined control sequence.
-<recently read> \\Zlpha
-
- main.tex, line 23
-
-`,
-}
-
-const mockBuildFile = (responses = defaultFileResponses) => {
-  fetchMock.get('begin:https://clsi.test-overleaf.com/', _url => {
-    const url = new URL(_url, 'https://clsi.test-overleaf.com')
-
-    if (url.pathname in responses) {
-      return responses[url.pathname]
-    }
-
-    return 404
-  })
-
-  fetchMock.get('express:/build/:file', (_url, options, request) => {
-    const url = new URL(_url, 'https://example.com')
-
-    if (url.pathname in responses) {
-      return responses[url.pathname]
-    }
-
-    return 404
-  })
-}
-
 const storeAndFireEvent = (key, value) => {
   localStorage.setItem(key, value)
   fireEvent(window, new StorageEvent('storage', { key }))
@@ -172,7 +46,6 @@ describe('<PdfPreview/>', function () {
   let clock
 
   beforeEach(function () {
-    window.showNewPdfPreview = true
     clock = sinon.useFakeTimers({
       shouldAdvanceTime: true,
       now: Date.now(),
@@ -181,7 +54,6 @@ describe('<PdfPreview/>', function () {
   })
 
   afterEach(function () {
-    window.showNewPdfPreview = undefined
     clock.runAll()
     clock.restore()
     fetchMock.reset()

services/web/test/frontend/features/pdf-preview/components/pdf-synctex-controls.test.js

@@ -95,7 +95,6 @@ const mockSynctex = () =>
 
 describe('<PdfSynctexControls/>', function () {
   beforeEach(function () {
-    window.showNewPdfPreview = true
     window.metaAttributesCache = new Map()
     fetchMock.restore()
     mockCompile()
@@ -104,7 +103,6 @@ describe('<PdfSynctexControls/>', function () {
   })
 
   afterEach(function () {
-    window.showNewPdfPreview = undefined
     window.metaAttributesCache = new Map()
     fetchMock.restore()
   })

services/web/test/frontend/features/pdf-preview/utils/mock-compile.js

@@ -0,0 +1,141 @@
+import fetchMock from 'fetch-mock'
+import { cloneDeep } from 'lodash'
+import nock from 'nock'
+import fs from 'fs'
+import path from 'path'
+
+export const examplePDF = path.join(__dirname, '../fixtures/test-example.pdf')
+export const corruptPDF = path.join(
+  __dirname,
+  '../fixtures/test-example-corrupt.pdf'
+)
+
+const outputFiles = [
+  {
+    path: 'output.pdf',
+    build: '123',
+    url: '/build/output.pdf',
+    type: 'pdf',
+  },
+  {
+    path: 'output.bbl',
+    build: '123',
+    url: '/build/output.bbl',
+    type: 'bbl',
+  },
+  {
+    path: 'output.bib',
+    build: '123',
+    url: '/build/output.bib',
+    type: 'bib',
+  },
+  {
+    path: 'example.txt',
+    build: '123',
+    url: '/build/example.txt',
+    type: 'txt',
+  },
+  {
+    path: 'output.log',
+    build: '123',
+    url: '/build/output.log',
+    type: 'log',
+  },
+  {
+    path: 'output.blg',
+    build: '123',
+    url: '/build/output.blg',
+    type: 'blg',
+  },
+]
+
+export const mockCompile = (delayPromise = Promise.resolve()) =>
+  fetchMock.post(
+    'express:/project/:projectId/compile',
+    delayPromise.then(() => ({
+      body: {
+        status: 'success',
+        clsiServerId: 'foo',
+        compileGroup: 'priority',
+        pdfDownloadDomain: 'https://clsi.test-overleaf.com',
+        outputFiles: cloneDeep(outputFiles),
+      },
+    }))
+  )
+
+export const mockCompileError = status =>
+  fetchMock.post('express:/project/:projectId/compile', {
+    body: {
+      status,
+      clsiServerId: 'foo',
+      compileGroup: 'priority',
+    },
+  })
+
+export const mockValidationProblems = validationProblems =>
+  fetchMock.post('express:/project/:projectId/compile', {
+    body: {
+      status: 'validation-problems',
+      validationProblems,
+      clsiServerId: 'foo',
+      compileGroup: 'priority',
+    },
+  })
+
+export const mockClearCache = () =>
+  fetchMock.delete('express:/project/:projectId/output', 204)
+
+export const mockValidPdf = () => {
+  nock('https://clsi.test-overleaf.com')
+    .get(/^\/build\/output\.pdf/)
+    .replyWithFile(200, examplePDF)
+}
+
+export const defaultFileResponses = {
+  '/build/output.pdf': () => fs.createReadStream(examplePDF),
+  '/build/output.blg': 'This is BibTeX, Version 4.0', // FIXME
+  '/build/output.log': `
+The LaTeX compiler output
+  * With a lot of details
+
+Wrapped in an HTML <pre> element with
+      preformatted text which is to be presented exactly
+            as written in the HTML file
+
+                                              (whitespace included™)
+
+The text is typically rendered using a non-proportional ("monospace") font.
+
+LaTeX Font Info:    External font \`cmex10' loaded for size
+(Font)              <7> on input line 18.
+LaTeX Font Info:    External font \`cmex10' loaded for size
+(Font)              <5> on input line 18.
+! Undefined control sequence.
+<recently read> \\Zlpha
+
+ main.tex, line 23
+
+`,
+}
+
+export const mockBuildFile = (responses = defaultFileResponses) => {
+  fetchMock.get('begin:https://clsi.test-overleaf.com/', _url => {
+    const url = new URL(_url, 'https://clsi.test-overleaf.com')
+
+    if (url.pathname in responses) {
+      return responses[url.pathname]
+    }
+
+    return 404
+  })
+
+  fetchMock.get('express:/build/:file', (_url, options, request) => {
+    const url = new URL(_url, 'https://example.com')
+
+    if (url.pathname in responses) {
+      return responses[url.pathname]
+    }
+
+    return 404
+  })
+}

services/web/test/frontend/features/preview/components/preview-download-button.test.js

@@ -1,86 +0,0 @@
-import { expect } from 'chai'
-import { screen, render } from '@testing-library/react'
-
-import PreviewDownloadButton from '../../../../../frontend/js/features/preview/components/preview-download-button'
-
-describe('<PreviewDownloadButton />', function () {
-  const projectId = 'projectId123'
-  const pdfDownloadUrl = `/download/project/${projectId}/build/17523aaafdf-1ad9063af140f004/output/output.pdf?compileGroup=priority&popupDownload=true`
-
-  function renderPreviewDownloadButton(
-    isCompiling,
-    outputFiles,
-    pdfDownloadUrl,
-    showText
-  ) {
-    if (isCompiling === undefined) isCompiling = false
-    if (showText === undefined) showText = true
-    render(
-      <PreviewDownloadButton
-        isCompiling={isCompiling}
-        outputFiles={outputFiles || []}
-        pdfDownloadUrl={pdfDownloadUrl}
-        showText={showText}
-      />
-    )
-  }
-
-  it('should disable the button and dropdown toggle when compiling', function () {
-    const isCompiling = true
-    const outputFiles = undefined
-
-    renderPreviewDownloadButton(isCompiling, outputFiles)
-
-    expect(
-      screen.getByText('Download PDF').closest('a').getAttribute('disabled')
-    ).to.exist
-    const buttons = screen.getAllByRole('button')
-    expect(buttons.length).to.equal(1) // the dropdown toggle
-    expect(buttons[0].getAttribute('disabled')).to.exist
-    expect(buttons[0].getAttribute('aria-label')).to.equal(
-      'Toggle output files list'
-    )
-  })
-  it('should disable the PDF button when there is no PDF', function () {
-    const isCompiling = false
-    const outputFiles = []
-    renderPreviewDownloadButton(isCompiling, outputFiles)
-    expect(
-      screen.getByText('Download PDF').closest('a').getAttribute('disabled')
-    ).to.exist
-  })
-  it('should enable the PDF button when there is a main PDF', function () {
-    const isCompiling = false
-    const outputFiles = []
-    renderPreviewDownloadButton(isCompiling, outputFiles, pdfDownloadUrl)
-    expect(
-      screen.getByText('Download PDF').closest('a').getAttribute('href')
-    ).to.equal(pdfDownloadUrl)
-    expect(
-      screen.getByText('Download PDF').closest('a').getAttribute('disabled')
-    ).to.not.exist
-  })
-  it('should enable the dropdown when not compiling', function () {
-    const isCompiling = false
-    const outputFiles = []
-    renderPreviewDownloadButton(isCompiling, outputFiles, pdfDownloadUrl)
-    const buttons = screen.getAllByRole('button')
-    expect(buttons[0]).to.exist
-    expect(buttons[0].getAttribute('disabled')).to.not.exist
-  })
-
-  it('should show the button text when prop showText=true', function () {
-    const isCompiling = false
-    const showText = true
-    renderPreviewDownloadButton(isCompiling, [], pdfDownloadUrl, showText)
-    expect(screen.getByText('Download PDF').getAttribute('style')).to.be.null
-  })
-  it('should not show the button text when prop showText=false', function () {
-    const isCompiling = false
-    const showText = false
-    renderPreviewDownloadButton(isCompiling, [], pdfDownloadUrl, showText)
-    expect(screen.getByText('Download PDF').getAttribute('style')).to.equal(
-      'position: absolute; right: -100vw;'
-    )
-  })
-})

services/web/test/frontend/features/preview/components/preview-download-file-list.test.js

@@ -1,120 +0,0 @@
-import { expect } from 'chai'
-import { screen, render } from '@testing-library/react'
-
-import PreviewDownloadFileList, {
-  topFileTypes,
-} from '../../../../../frontend/js/features/preview/components/preview-download-file-list'
-
-describe('<PreviewDownloadFileList />', function () {
-  const projectId = 'projectId123'
-
-  function makeFile(fileName, main) {
-    return {
-      fileName,
-      url: `/project/${projectId}/output/${fileName}`,
-      type: fileName.split('.').pop(),
-      main: main || false,
-    }
-  }
-
-  it('should list all output files and group them', function () {
-    const outputFiles = [
-      makeFile('output.ind'),
-      makeFile('output.log'),
-      makeFile('output.pdf', true),
-      makeFile('alt.pdf'),
-      makeFile('output.stderr'),
-      makeFile('output.stdout'),
-      makeFile('output.aux'),
-      makeFile('output.bbl'),
-      makeFile('output.blg'),
-    ]
-
-    render(<PreviewDownloadFileList fileList={outputFiles} />)
-
-    const menuItems = screen.getAllByRole('menuitem')
-    expect(menuItems.length).to.equal(outputFiles.length - 1) // main PDF is listed separately
-
-    const fileTypes = outputFiles.map(file => {
-      return file.type
-    })
-    menuItems.forEach((item, index) => {
-      // check displayed text
-      const fileType = item.textContent.split('.').pop()
-      expect(fileTypes).to.include(fileType)
-    })
-
-    // check grouped correctly
-    expect(topFileTypes).to.exist
-    expect(topFileTypes.length).to.be.above(0)
-    const outputTopFileTypes = outputFiles
-      .filter(file => {
-        return topFileTypes.includes(file.type)
-      })
-      .map(file => file.type)
-    const topMenuItems = menuItems.slice(0, outputTopFileTypes.length)
-    topMenuItems.forEach(item => {
-      const fileType = item.textContent.split('.').pop().replace(' file', '')
-      expect(topFileTypes.includes(fileType)).to.be.true
-    })
-  })
-
-  it('should list all files when there are duplicate types', function () {
-    const pdfFile = makeFile('output.pdf', true)
-    const bblFile = makeFile('output.bbl')
-    const outputFiles = [Object.assign({}, { ...bblFile }), bblFile, pdfFile]
-
-    render(<PreviewDownloadFileList fileList={outputFiles} />)
-
-    const bblMenuItems = screen.getAllByText((content, element) => {
-      return content !== '' && element.textContent === 'output.bbl'
-    })
-    expect(bblMenuItems.length).to.equal(2)
-  })
-
-  it('should list the non-main PDF in the dropdown', function () {
-    const pdfFile = makeFile('output.pdf', true)
-    const pdfAltFile = makeFile('alt.pdf')
-    const outputFiles = [pdfFile, pdfAltFile]
-    render(<PreviewDownloadFileList fileList={outputFiles} />)
-    screen.getAllByRole('menuitem', { name: 'alt.pdf' })
-  })
-
-  describe('list divider and header', function () {
-    it('should display when there are top files and other files', function () {
-      const outputFiles = [
-        makeFile('output.bbl'),
-        makeFile('output.ind'),
-        makeFile('output.gls'),
-        makeFile('output.log'),
-      ]
-
-      render(<PreviewDownloadFileList fileList={outputFiles} />)
-
-      screen.getByText('Download other output files')
-      screen.getByRole('separator')
-    })
-
-    it('should not display when there are top files and no other files', function () {
-      const outputFiles = [
-        makeFile('output.bbl'),
-        makeFile('output.ind'),
-        makeFile('output.gls'),
-      ]
-
-      render(<PreviewDownloadFileList fileList={outputFiles} />)
-
-      expect(screen.queryByText('Other output files')).to.not.exist
-      expect(screen.queryByRole('separator')).to.not.exist
-    })
-
-    it('should not display when there are other files and no top files', function () {
-      const outputFiles = [makeFile('output.log')]
-
-      render(<PreviewDownloadFileList fileList={outputFiles} />)
-
-      expect(screen.queryByText('Other output files')).to.not.exist
-      expect(screen.queryByRole('separator')).to.not.exist
-    })
-  })
-})

services/web/test/frontend/features/preview/components/preview-logs-pane-entry.test.js

@@ -1,181 +0,0 @@
-import { expect } from 'chai'
-import sinon from 'sinon'
-import { screen, render, fireEvent } from '@testing-library/react'
-
-import PreviewLogsPaneEntry from '../../../../../frontend/js/features/preview/components/preview-logs-pane-entry.js'
-
-describe('<PreviewLogsPaneEntry />', function () {
-  const level = 'error'
-
-  it('renders a configurable aria-label', function () {
-    const sampleAriaLabel = 'lorem ipsum dolor sit amet'
-    render(
-      <PreviewLogsPaneEntry entryAriaLabel={sampleAriaLabel} level={level} />
-    )
-    screen.getByLabelText(sampleAriaLabel)
-  })
-
-  describe('logs pane source location link', function () {
-    const file = 'foo.tex'
-    const line = 42
-    const column = 21
-    const onSourceLocationClick = sinon.stub()
-
-    afterEach(function () {
-      onSourceLocationClick.reset()
-    })
-
-    it('renders both file and line', function () {
-      render(
-        <PreviewLogsPaneEntry sourceLocation={{ file, line }} level={level} />
-      )
-      screen.getByRole('button', {
-        name: `Navigate to log position in source code: ${file}, ${line}`,
-      })
-    })
-
-    it('renders only file when line information is not available', function () {
-      render(<PreviewLogsPaneEntry sourceLocation={{ file }} level={level} />)
-      screen.getByRole('button', {
-        name: `Navigate to log position in source code: ${file}`,
-      })
-    })
-
-    it('does not render when file information is not available', function () {
-      render(<PreviewLogsPaneEntry level={level} />)
-      expect(
-        screen.queryByRole('button', {
-          name: `Navigate to log position in source code: `,
-        })
-      ).to.not.exist
-    })
-
-    it('calls the callback with file, line and column on click', function () {
-      render(
-        <PreviewLogsPaneEntry
-          sourceLocation={{ file, line, column }}
-          level={level}
-          onSourceLocationClick={onSourceLocationClick}
-        />
-      )
-      const linkToSourceButton = screen.getByRole('button', {
-        name: `Navigate to log position in source code: ${file}, ${line}`,
-      })
-
-      fireEvent.click(linkToSourceButton)
-      expect(onSourceLocationClick).to.be.calledOnce
-      expect(onSourceLocationClick).to.be.calledWith({
-        file,
-        line,
-        column,
-      })
-    })
-  })
-
-  describe('logs pane entry raw contents', function () {
-    const rawContent = 'foo bar latex error stuff baz'
-
-    // JSDom doesn't compute layout/sizing, so we need to simulate sizing for the elements
-    // Here we are simulating that the content is bigger than the `collapsedSize`, so
-    // the expand-collapse widget is used
-    const originalScrollHeight = Object.getOwnPropertyDescriptor(
-      HTMLElement.prototype,
-      'offsetHeight'
-    )
-    const originalScrollWidth = Object.getOwnPropertyDescriptor(
-      HTMLElement.prototype,
-      'offsetWidth'
-    )
-
-    beforeEach(function () {
-      Object.defineProperty(HTMLElement.prototype, 'scrollHeight', {
-        configurable: true,
-        value: 500,
-      })
-      Object.defineProperty(HTMLElement.prototype, 'scrollWidth', {
-        configurable: true,
-        value: 500,
-      })
-    })
-
-    afterEach(function () {
-      Object.defineProperty(
-        HTMLElement.prototype,
-        'scrollHeight',
-        originalScrollHeight
-      )
-      Object.defineProperty(
-        HTMLElement.prototype,
-        'scrollWidth',
-        originalScrollWidth
-      )
-    })
-
-    it('renders collapsed contents by default', function () {
-      render(<PreviewLogsPaneEntry rawContent={rawContent} level={level} />)
-      screen.getByText(rawContent)
-      screen.getByRole('button', {
-        name: 'Expand',
-      })
-    })
-
-    it('supports expanding contents', function () {
-      render(<PreviewLogsPaneEntry rawContent={rawContent} level={level} />)
-      screen.getByText(rawContent)
-      const expandCollapseBtn = screen.getByRole('button', {
-        name: 'Expand',
-      })
-      fireEvent.click(expandCollapseBtn)
-      screen.getByRole('button', {
-        name: 'Collapse',
-      })
-    })
-
-    it('should not render at all when there are no log contents', function () {
-      const { container } = render(<PreviewLogsPaneEntry level={level} />)
-      expect(container.querySelector('.log-entry-content')).to.not.exist
-    })
-  })
-
-  describe('formatted content', function () {
-    const rawContent = 'foo bar latex error stuff baz'
-    const formattedContentText = 'foo bar baz'
-    const formattedContent = <>{formattedContentText}</>
-    const infoURL = 'www.overleaf.com/learn/latex'
-
-    it('renders the hint', function () {
-      render(
-        <PreviewLogsPaneEntry
-          rawContent={rawContent}
-          formattedContent={formattedContent}
-          extraInfoURL={infoURL}
-          level={level}
-        />
-      )
-      screen.getByText(formattedContentText)
-    })
-
-    it('renders the link to learn more', function () {
-      render(
-        <PreviewLogsPaneEntry
-          rawContent={rawContent}
-          formattedContent={formattedContent}
-          extraInfoURL={infoURL}
-          level={level}
-        />
-      )
-      screen.getByRole('link', { name: 'Learn more' })
-    })
-
-    it('does not render the link when it is not available', function () {
-      render(
-        <PreviewLogsPaneEntry
-          rawContent={rawContent}
-          formattedContent={formattedContent}
-          level={level}
-        />
-      )
-      expect(screen.queryByRole('link', { name: 'Learn more' })).to.not.exist
-    })
-  })
-})

services/web/test/frontend/features/preview/components/preview-logs-pane.test.js

@@ -1,241 +0,0 @@
-import { screen, fireEvent } from '@testing-library/react'
-import PreviewLogsPane from '../../../../../frontend/js/features/preview/components/preview-logs-pane'
-import sinon from 'sinon'
-import { renderWithEditorContext } from '../../../helpers/render-with-context'
-
-const { expect } = require('chai')
-
-describe('<PreviewLogsPane />', function () {
-  const sampleError1 = {
-    content: 'error 1 content',
-    file: 'main.tex',
-    level: 'error',
-    line: 17,
-    message: 'Misplaced alignment tab character &.',
-  }
-  const sampleError2 = {
-    content: 'error 1 content',
-    file: 'main.tex',
-    level: 'error',
-    line: 22,
-    message: 'Extra alignment tab has been changed to cr.',
-  }
-  const sampleWarning = {
-    file: 'main.tex',
-    level: 'warning',
-    line: 30,
-    message: "Reference `idontexist' on page 1 undefined on input line 30.",
-  }
-  const sampleTypesettingIssue = {
-    file: 'main.tex',
-    level: 'typesetting',
-    line: 12,
-    message: "Reference `idontexist' on page 1 undefined on input line 30.",
-  }
-  const sampleRawLog = `
-  This is pdfTeX, Version 3.14159265-2.6-1.40.21 (TeX Live 2020) (preloaded format=pdflatex 2020.9.10)  6 NOV 2020 15:23
-entering extended mode
- \\write18 enabled.
- %&-line parsing enabled.
-**main.tex
-(/compile/main.tex
-  LaTeX2e <2020-02-02> patch level 5
-  L3 programming layer <2020-07-17> (/usr/local/texlive/2020/texmf-dist/tex/latex
-  /base/article.cls
-  Document Class: article 2019/12/20 v1.4l Standard LaTeX document class
-  (/usr/local/texlive/2020/texmf-dist/tex/latex/base/size10.clo
-  File: size10.clo 2019/12/20 v1.4l Standard LaTeX file (size option)
-  )`
-  const errors = [sampleError1, sampleError2]
-  const warnings = [sampleWarning]
-  const typesetting = [sampleTypesettingIssue]
-  const logEntries = {
-    all: [...errors, ...warnings, ...typesetting],
-    errors,
-    warnings,
-    typesetting,
-  }
-  const noOp = () => {}
-  const onLogEntryLocationClick = sinon.stub()
-
-  describe('with logs', function () {
-    beforeEach(function () {
-      renderWithEditorContext(
-        <PreviewLogsPane
-          logEntries={logEntries}
-          rawLog={sampleRawLog}
-          onLogEntryLocationClick={onLogEntryLocationClick}
-          onClearCache={noOp}
-        />
-      )
-    })
-    it('renders all log entries with appropriate labels', function () {
-      const errorEntries = screen.getAllByLabelText(
-        `Log entry with level: error`
-      )
-      const warningEntries = screen.getAllByLabelText(
-        `Log entry with level: warning`
-      )
-      const typesettingEntries = screen.getAllByLabelText(
-        `Log entry with level: typesetting`
-      )
-      expect(errorEntries).to.have.lengthOf(errors.length)
-      expect(warningEntries).to.have.lengthOf(warnings.length)
-      expect(typesettingEntries).to.have.lengthOf(typesetting.length)
-    })
-
-    it('renders the raw log', function () {
-      screen.getByLabelText('Raw logs from the LaTeX compiler')
-    })
-
-    it('renders a link to location button for every error and warning log entry', function () {
-      logEntries.all.forEach((entry, index) => {
-        const linkToSourceButton = screen.getByRole('button', {
-          name: `Navigate to log position in source code: ${entry.file}, ${entry.line}`,
-        })
-        fireEvent.click(linkToSourceButton)
-        expect(onLogEntryLocationClick).to.have.callCount(index + 1)
-        const call = onLogEntryLocationClick.getCall(index)
-        expect(
-          call.calledWith({
-            file: entry.file,
-            line: entry.line,
-            column: entry.column,
-          })
-        ).to.be.true
-      })
-    })
-    it(' does not render a link to location button for the raw log entry', function () {
-      const rawLogEntry = screen.getByLabelText(
-        'Raw logs from the LaTeX compiler'
-      )
-      expect(rawLogEntry.querySelector('.log-entry-header-link')).to.not.exist
-    })
-  })
-
-  describe('with over 100 log entries', function () {
-    it('renders only 100 with a warning message', function () {
-      const errors = Array(200).fill(sampleError1)
-      const logEntries = {
-        all: [...errors, ...warnings, ...typesetting],
-        errors,
-        warnings,
-        typesetting,
-      }
-
-      renderWithEditorContext(
-        <PreviewLogsPane
-          logEntries={logEntries}
-          rawLog={sampleRawLog}
-          onLogEntryLocationClick={onLogEntryLocationClick}
-          onClearCache={noOp}
-        />
-      )
-
-      const displayedLogEntries = screen.getAllByLabelText(
-        `Log entry with level`,
-        { exact: false }
-      )
-      screen.getByLabelText(`Maximum log entries limit hit`)
-      // should only show the first 100 errors and stop
-      expect(displayedLogEntries).to.have.lengthOf(100)
-    })
-  })
-
-  describe('with validation issues', function () {
-    const sampleValidationIssues = {
-      sizeCheck: {
-        resources: [
-          { path: 'foo/bar', kbSize: 76221 },
-          { path: 'bar/baz', kbSize: 2342 },
-        ],
-      },
-      mainFile: true,
-    }
-
-    it('renders a validation entry for known issues', function () {
-      renderWithEditorContext(
-        <PreviewLogsPane
-          validationIssues={sampleValidationIssues}
-          onLogEntryLocationClick={onLogEntryLocationClick}
-          onClearCache={noOp}
-        />
-      )
-      const validationEntries = screen.getAllByLabelText(
-        'A validation issue which prevented this project from compiling'
-      )
-      expect(validationEntries).to.have.lengthOf(
-        Object.keys(sampleValidationIssues).length
-      )
-    })
-
-    it('ignores unknown issues', function () {
-      renderWithEditorContext(
-        <PreviewLogsPane
-          validationIssues={{ unknownIssue: true }}
-          onLogEntryLocationClick={onLogEntryLocationClick}
-          onClearCache={noOp}
-        />
-      )
-      const validationEntries = screen.queryAllByLabelText(
-        'A validation issue prevented this project from compiling'
-      )
-      expect(validationEntries).to.have.lengthOf(0)
-    })
-  })
-
-  describe('with compilation errors', function () {
-    const sampleErrors = {
-      clsiMaintenance: true,
-      tooRecentlyCompiled: true,
-      compileTerminated: true,
-    }
-
-    it('renders an error entry for known errors', function () {
-      renderWithEditorContext(
-        <PreviewLogsPane
-          errors={sampleErrors}
-          onLogEntryLocationClick={onLogEntryLocationClick}
-          onClearCache={noOp}
-        />
-      )
-      const errorEntries = screen.getAllByLabelText(
-        'An error which prevented this project from compiling'
-      )
-      expect(errorEntries).to.have.lengthOf(Object.keys(sampleErrors).length)
-    })
-
-    it('ignores unknown errors', function () {
-      renderWithEditorContext(
-        <PreviewLogsPane
-          errors={{ unknownIssue: true }}
-          onLogEntryLocationClick={onLogEntryLocationClick}
-          onClearCache={noOp}
-        />
-      )
-      const errorEntries = screen.queryAllByLabelText(
-        'There was an error compiling this project'
-      )
-      expect(errorEntries).to.have.lengthOf(0)
-    })
-  })
-
-  describe('with failing code check', function () {
-    beforeEach(function () {
-      renderWithEditorContext(
-        <PreviewLogsPane
-          logEntries={logEntries}
-          rawLog={sampleRawLog}
-          onLogEntryLocationClick={onLogEntryLocationClick}
-          onClearCache={noOp}
-          autoCompileHasLintingError
-        />
-      )
-    })
-    it('renders a code check failed entry', function () {
-      screen.getByText(
-        'Your code has errors that need to be fixed before the auto-compile can run'
-      )
-    })
-  })
-})

services/web/test/frontend/features/preview/components/preview-logs-toggle-button.test.js

@@ -1,146 +0,0 @@
-import { expect } from 'chai'
-import { screen, render } from '@testing-library/react'
-
-import PreviewLogsToggleButton from '../../../../../frontend/js/features/preview/components/preview-logs-toggle-button'
-
-describe('<PreviewLogsToggleButton />', function () {
-  function renderPreviewLogsToggleButton(
-    logsState,
-    onToggleLogs,
-    showLogs,
-    showText = false,
-    autoCompileLintingError = false,
-    compileFailed = false
-  ) {
-    render(
-      <PreviewLogsToggleButton
-        logsState={logsState}
-        onToggle={onToggleLogs}
-        showLogs={showLogs}
-        showText={showText}
-        autoCompileLintingError={autoCompileLintingError}
-        compileFailed={compileFailed}
-      />
-    )
-  }
-
-  describe('basic toggle functionality', function () {
-    const logsState = {
-      nErrors: 0,
-      nWarnings: 0,
-    }
-    const onToggleLogs = () => {}
-    it('should render a view logs button when previewing the PDF', function () {
-      const showLogs = false
-      renderPreviewLogsToggleButton(logsState, onToggleLogs, showLogs)
-      screen.getByText('View logs')
-    })
-    it('should render a view PDF button when viewing logs', function () {
-      const showLogs = true
-      renderPreviewLogsToggleButton(logsState, onToggleLogs, showLogs)
-      screen.getByText('View PDF')
-    })
-  })
-  describe('compile status indicator', function () {
-    const showLogs = false
-    const onToggleLogs = () => {}
-    it('should render a view logs button by default', function () {
-      const logsState = {
-        nErrors: 0,
-        nWarnings: 0,
-      }
-      renderPreviewLogsToggleButton(logsState, onToggleLogs, showLogs)
-      screen.getByText('View logs')
-    })
-
-    it('should render the code check failed notice', function () {
-      const logsState = {
-        nErrors: 1,
-        nWarnings: 0,
-      }
-      renderPreviewLogsToggleButton(
-        logsState,
-        onToggleLogs,
-        showLogs,
-        false,
-        true
-      )
-      screen.getByText('Code check failed')
-    })
-
-    it('should render an error status message without a count when there is a single error', function () {
-      const logsState = {
-        nErrors: 1,
-        nWarnings: 0,
-      }
-      renderPreviewLogsToggleButton(logsState, onToggleLogs, showLogs)
-      screen.getByText('This project has an error')
-    })
-
-    it('should render an error status message with a count when there are multiple errors', function () {
-      const logsState = {
-        nErrors: 10,
-        nWarnings: 0,
-      }
-      renderPreviewLogsToggleButton(logsState, onToggleLogs, showLogs)
-      screen.getByText(`This project has errors (${logsState.nErrors})`)
-    })
-
-    it('should render an error status message when there are both errors and warnings', function () {
-      const logsState = {
-        nErrors: 1,
-        nWarnings: 1,
-      }
-      renderPreviewLogsToggleButton(logsState, onToggleLogs, showLogs)
-      screen.getByText('This project has an error')
-    })
-
-    it('should render a warning status message without a count when there is a single warning and no errors', function () {
-      const logsState = {
-        nErrors: 0,
-        nWarnings: 1,
-      }
-      renderPreviewLogsToggleButton(logsState, onToggleLogs, showLogs)
-      screen.getByText('View warning')
-    })
-
-    it('should render a warning status message with a count when there are multiple warnings and no errors', function () {
-      const logsState = {
-        nErrors: 0,
-        nWarnings: 10,
-      }
-      renderPreviewLogsToggleButton(logsState, onToggleLogs, showLogs)
-      screen.getByText(`View warnings (${logsState.nWarnings})`)
-    })
-
-    it('should render 99+ errors when there are more than 99 errors', function () {
-      const logsState = {
-        nErrors: 100,
-        nWarnings: 0,
-      }
-      renderPreviewLogsToggleButton(logsState, onToggleLogs, showLogs)
-      screen.getByText('This project has errors (99+)')
-    })
-
-    it('should show the button text when prop showText=true', function () {
-      const logsState = {
-        nErrors: 0,
-        nWarnings: 0,
-      }
-      const showText = true
-      renderPreviewLogsToggleButton(logsState, onToggleLogs, showLogs, showText)
-      expect(screen.getByText('View logs').getAttribute('style')).to.be.null
-    })
-    it('should not show the button text when prop showText=false', function () {
-      const logsState = {
-        nErrors: 0,
-        nWarnings: 0,
-      }
-      const showText = false
-      renderPreviewLogsToggleButton(logsState, onToggleLogs, showLogs, showText)
-      expect(screen.getByText('View logs').getAttribute('style')).to.equal(
-        'position: absolute; right: -100vw;'
-      )
-    })
-  })
-})

services/web/test/frontend/features/preview/components/preview-pane.test.js

@@ -1,305 +0,0 @@
-import { screen, render, fireEvent } from '@testing-library/react'
-import PreviewPane from '../../../../../frontend/js/features/preview/components/preview-pane'
-const { expect } = require('chai')
-
-describe('<PreviewPane />', function () {
-  const sampleError1 = {
-    content: 'error 1 content',
-    file: 'main.tex',
-    level: 'error',
-    line: 17,
-    message: 'Misplaced alignment tab character &.',
-  }
-  const sampleError2 = {
-    content: 'error 1 content',
-    file: 'main.tex',
-    level: 'error',
-    line: 22,
-    message: 'Extra alignment tab has been changed to cr.',
-  }
-  const sampleWarning = {
-    file: 'main.tex',
-    level: 'warning',
-    line: 30,
-    message: "Reference `idontexist' on page 1 undefined on input line 30.",
-  }
-
-  describe('first error pop-up', function () {
-    it('renders a first error pop-up with the first error', function () {
-      const propsAfterCompileWithErrors = getProps(false, {
-        errors: [sampleError1, sampleError2],
-        warnings: [sampleWarning],
-      })
-      render(<PreviewPane {...propsAfterCompileWithErrors} />)
-      screen.getByRole('alertdialog', {
-        name: 'This project has errors. This is the first one.',
-      })
-      screen.getByText(sampleError1.message)
-    })
-
-    it('does not render a first error pop-up when there are only warnings', function () {
-      const propsAfterCompileWithWarningsOnly = getProps(false, {
-        errors: [],
-        warnings: [sampleWarning],
-      })
-      render(<PreviewPane {...propsAfterCompileWithWarningsOnly} />)
-      expect(
-        screen.queryByRole('alertdialog', {
-          name: 'This project has errors. This is the first one.',
-        })
-      ).to.not.exist
-    })
-
-    it('does not render a first error pop-up when a compile is ongoing', function () {
-      const propsWhileCompiling = getProps(true, {
-        errors: [sampleError1, sampleError2],
-        warnings: [sampleWarning],
-      })
-      render(<PreviewPane {...propsWhileCompiling} />)
-      expect(
-        screen.queryByRole('alertdialog', {
-          name: 'This project has errors. This is the first one.',
-        })
-      ).to.not.exist
-    })
-
-    it('does not render a first error pop-up when viewing logs', function () {
-      const propsWithErrorsViewingLogs = getProps(
-        false,
-        {
-          errors: [sampleError1, sampleError2],
-          warnings: [sampleWarning],
-        },
-        Date.now(),
-        true
-      )
-      render(<PreviewPane {...propsWithErrorsViewingLogs} />)
-      expect(
-        screen.queryByRole('alertdialog', {
-          name: 'This project has errors. This is the first one.',
-        })
-      ).to.not.exist
-    })
-
-    it('does not render a first error pop-up when going back to the PDF view after viewing logs', function () {
-      const nowTimestamp = Date.now()
-      const propsWithErrorsViewingLogs = getProps(
-        false,
-        {
-          errors: [sampleError1, sampleError2],
-          warnings: [sampleWarning],
-        },
-        nowTimestamp,
-        true
-      )
-      const propsWithErrorsAfterViewingLogs = getProps(
-        false,
-        {
-          errors: [sampleError1, sampleError2],
-          warnings: [sampleWarning],
-        },
-        nowTimestamp,
-        false
-      )
-      const { rerender } = render(
-        <PreviewPane {...propsWithErrorsViewingLogs} />
-      )
-      rerender(<PreviewPane {...propsWithErrorsAfterViewingLogs} />)
-      expect(
-        screen.queryByRole('alertdialog', {
-          name: 'This project has errors. This is the first one.',
-        })
-      ).to.not.exist
-    })
-
-    it('renders a first error pop-up with updated errors after recompiling', function () {
-      const nowTimestamp = Date.now()
-      const laterTimestamp = Date.now() + 1000
-      const propsWithErrorsAfterFirstCompile = getProps(
-        false,
-        {
-          errors: [sampleError1, sampleError2],
-          warnings: [sampleWarning],
-        },
-        nowTimestamp,
-        true
-      )
-      const propsWithErrorsAfterSecondCompile = getProps(
-        false,
-        {
-          errors: [sampleError2],
-          warnings: [sampleWarning],
-        },
-        laterTimestamp,
-        false
-      )
-      const { rerender } = render(
-        <PreviewPane {...propsWithErrorsAfterFirstCompile} />
-      )
-      rerender(<PreviewPane {...propsWithErrorsAfterSecondCompile} />)
-      screen.getByRole('alertdialog', {
-        name: 'This project has errors. This is the first one.',
-      })
-      screen.getByText(sampleError2.message)
-    })
-
-    it('allows dismissing the first error pop-up', function () {
-      const propsWithErrors = getProps(false, {
-        errors: [sampleError1, sampleError2],
-        warnings: [sampleWarning],
-      })
-      render(<PreviewPane {...propsWithErrors} />)
-      const dismissPopUpButton = screen.getByRole('button', {
-        name: 'Dismiss first error alert',
-      })
-
-      fireEvent.click(dismissPopUpButton)
-      expect(
-        screen.queryByRole('alertdialog', {
-          name: 'This project has errors. This is the first one.',
-        })
-      ).to.not.exist
-    })
-
-    it('does not render the first error pop-up with new recompiles after it being dismissed once', function () {
-      const nowTimestamp = Date.now()
-      const laterTimestamp = Date.now() + 1000
-      const propsWithErrorsForFirstCompile = getProps(
-        false,
-        {
-          errors: [sampleError1, sampleError2],
-          warnings: [sampleWarning],
-        },
-        nowTimestamp
-      )
-      const propsWithErrorsForSecondCompile = getProps(
-        false,
-        {
-          errors: [sampleError2],
-          warnings: [sampleWarning],
-        },
-        laterTimestamp
-      )
-      const { rerender } = render(
-        <PreviewPane {...propsWithErrorsForFirstCompile} />
-      )
-      const dismissPopUpButton = screen.getByRole('button', {
-        name: 'Dismiss first error alert',
-      })
-      fireEvent.click(dismissPopUpButton)
-      rerender(<PreviewPane {...propsWithErrorsForSecondCompile} />)
-      expect(
-        screen.queryByRole('alertdialog', {
-          name: 'This project has errors. This is the first one.',
-        })
-      ).to.not.exist
-    })
-  })
-
-  describe('accessible description of the compile result', function () {
-    it('renders an accessible description with the errors and warnings count', function () {
-      const errors = [sampleError1, sampleError2]
-      const warnings = [sampleWarning]
-      const propsWithErrorsAndWarnings = getProps(false, {
-        errors,
-        warnings,
-      })
-      render(<PreviewPane {...propsWithErrorsAndWarnings} />)
-
-      screen.getByText(`${errors.length} error${errors.length > 1 ? 's' : ''}`)
-      screen.getByText(
-        `${warnings.length} warning${warnings.length > 1 ? 's' : ''}`
-      )
-    })
-    it('renders an accessible description for failed compiles with CLSI errors', function () {
-      const sampleCLSIError = {
-        clsiMaintenance: true,
-      }
-
-      const propsWithCLSIError = getProps(
-        false,
-        {},
-        Date.now(),
-        false,
-        true,
-        {},
-        sampleCLSIError
-      )
-      render(<PreviewPane {...propsWithCLSIError} />)
-
-      screen.getByText('This project did not compile because of an error')
-    })
-
-    it('renders an accessible description for failed compiles with validation issues', function () {
-      const sampleValidationIssue = {
-        clsiMaintenance: true,
-      }
-
-      const propsWithValidationIssue = getProps(
-        false,
-        {},
-        Date.now(),
-        false,
-        true,
-        sampleValidationIssue,
-        {}
-      )
-      render(<PreviewPane {...propsWithValidationIssue} />)
-
-      screen.getByText(
-        'This project did not compile because of a validation issue'
-      )
-    })
-  })
-
-  function getProps(
-    isCompiling = false,
-    logEntries = {},
-    lastCompileTimestamp = Date.now(),
-    isShowingLogs = false,
-    compileFailed = false,
-    validationIssues = {},
-    errors = {}
-  ) {
-    const logEntriesWithDefaults = {
-      errors: [],
-      warnings: [],
-      typesetting: [],
-      ...logEntries,
-    }
-    logEntriesWithDefaults.all = [
-      ...logEntriesWithDefaults.errors,
-      ...logEntriesWithDefaults.warnings,
-      ...logEntriesWithDefaults.typesetting,
-    ]
-    return {
-      compilerState: {
-        autoCompileHasChanges: false,
-        isAutoCompileOn: false,
-        isCompiling: isCompiling,
-        isClearingCache: false,
-        isDraftModeOn: false,
-        isSyntaxCheckOn: false,
-        lastCompileTimestamp,
-        logEntries: logEntriesWithDefaults,
-        compileFailed,
-        validationIssues,
-        errors,
-      },
-      onClearCache: () => {},
-      onLogEntryLocationClick: () => {},
-      onRecompile: () => {},
-      onRecompileFromScratch: () => {},
-      onRunSyntaxCheckNow: () => {},
-      onSetAutoCompile: () => {},
-      onSetDraftMode: () => {},
-      onSetSyntaxCheck: () => {},
-      onToggleLogs: () => {},
-      onSetSplitLayout: () => {},
-      onSetFullLayout: () => {},
-      onStopCompilation: () => {},
-      showLogs: isShowingLogs,
-      splitLayout: true,
-    }
-  }
-})

services/web/test/frontend/features/preview/components/preview-recompile-button.test.js

@@ -1,148 +0,0 @@
-import sinon from 'sinon'
-import { screen, render, fireEvent } from '@testing-library/react'
-import PreviewRecompileButton from '../../../../../frontend/js/features/preview/components/preview-recompile-button'
-const { expect } = require('chai')
-
-describe('<PreviewRecompileButton />', function () {
-  let onRecompile, onRecompileFromScratch, onStopCompilation
-
-  beforeEach(function () {
-    onRecompile = sinon.stub().resolves()
-    onRecompileFromScratch = sinon.stub().resolves()
-    onStopCompilation = sinon.stub().resolves()
-  })
-
-  it('renders all items', function () {
-    renderPreviewRecompileButton()
-
-    const menuItems = screen.getAllByRole('menuitem')
-    expect(menuItems.length).to.equal(9)
-    expect(menuItems.map(item => item.textContent)).to.deep.equal([
-      'On',
-      'Off',
-      'Normal',
-      'Fast [draft]',
-      'Check syntax before compile',
-      'Don’t check syntax',
-      'Run syntax check now',
-      'Stop compilation',
-      'Recompile from scratch',
-    ])
-
-    const menuHeadingItems = screen.getAllByRole('heading')
-    expect(menuHeadingItems.length).to.equal(3)
-    expect(menuHeadingItems.map(item => item.textContent)).to.deep.equal([
-      'Auto Compile',
-      'Compile Mode',
-      'Syntax Checks',
-    ])
-  })
-
-  describe('Recompile from scratch', function () {
-    describe('click', function () {
-      it('should call onRecompileFromScratch', async function () {
-        renderPreviewRecompileButton()
-
-        const button = screen.getByRole('menuitem', {
-          name: 'Recompile from scratch',
-        })
-        await fireEvent.click(button)
-        expect(onRecompileFromScratch).to.have.been.calledOnce
-      })
-    })
-    describe('processing', function () {
-      it('shows processing view and disable menuItem when recompiling', function () {
-        renderPreviewRecompileButton({ isCompiling: true })
-
-        screen.getByRole('button', { name: 'Compiling…' })
-        expect(
-          screen
-            .getByRole('menuitem', {
-              name: 'Recompile from scratch',
-            })
-            .getAttribute('aria-disabled')
-        ).to.equal('true')
-        expect(
-          screen
-            .getByRole('menuitem', {
-              name: 'Recompile from scratch',
-            })
-            .closest('li')
-            .getAttribute('class')
-        ).to.equal('disabled')
-      })
-    })
-  })
-
-  it('should show the button text when prop showText=true', function () {
-    const showText = true
-    renderPreviewRecompileButton({}, showText)
-    expect(screen.getByText('Recompile').getAttribute('style')).to.be.null
-  })
-  it('should not show the button text when prop showText=false', function () {
-    const showText = false
-    renderPreviewRecompileButton({}, showText)
-    expect(screen.getByText('Recompile').getAttribute('style')).to.equal(
-      'position: absolute; right: -100vw;'
-    )
-  })
-
-  describe('Autocompile feedback', function () {
-    it('shows animated visual feedback via CSS class when there are uncompiled changes', function () {
-      const { container } = renderPreviewRecompileButton({
-        autoCompileHasChanges: true,
-        autoCompileHasLintingError: false,
-      })
-      const recompileBtnGroupEl = container.querySelector(
-        '.btn-recompile-group'
-      )
-      expect(
-        recompileBtnGroupEl.classList.contains(
-          'btn-recompile-group-has-changes'
-        )
-      ).to.be.true
-    })
-    it('does not show animated visual feedback via CSS class when there are no uncompiled changes', function () {
-      const { container } = renderPreviewRecompileButton({
-        autoCompileHasChanges: false,
-        autoCompileHasLintingError: false,
-      })
-      const recompileBtnGroupEl = container.querySelector(
-        '.btn-recompile-group'
-      )
-      expect(
-        recompileBtnGroupEl.classList.contains(
-          'btn-recompile-group-has-changes'
-        )
-      ).to.be.false
-    })
-  })
-
-  function renderPreviewRecompileButton(compilerState = {}, showText) {
-    if (!compilerState.logEntries) {
-      compilerState.logEntries = {}
-    }
-    if (showText === undefined) showText = true
-    return render(
-      <PreviewRecompileButton
-        compilerState={{
-          autoCompileHasChanges: false,
-          isAutoCompileOn: true,
-          isClearingCache: false,
-          isCompiling: false,
-          isDraftModeOn: false,
-          isSyntaxCheckOn: false,
-          ...compilerState,
-        }}
-        onRecompile={onRecompile}
-        onRunSyntaxCheckNow={() => {}}
-        onSetAutoCompile={() => {}}
-        onSetDraftMode={() => {}}
-        onSetSyntaxCheck={() => {}}
-        onRecompileFromScratch={onRecompileFromScratch}
-        onStopCompilation={onStopCompilation}
-        showText={showText}
-      />
-    )
-  }
-})

services/web/test/frontend/features/preview/components/preview-toolbar.test.js

@@ -1,96 +0,0 @@
-import sinon from 'sinon'
-import { expect } from 'chai'
-import { screen, render, fireEvent } from '@testing-library/react'
-import PreviewToolbar from '../../../../../frontend/js/features/preview/components/preview-toolbar'
-
-describe('<PreviewToolbar />', function () {
-  const onRecompile = sinon.stub()
-  const onRecompileFromScratch = sinon.stub()
-  const onRunSyntaxCheckNow = sinon.stub()
-  const onSetAutoCompile = sinon.stub()
-  const onSetDraftMode = sinon.stub()
-  const onSetSyntaxCheck = sinon.stub()
-  const onToggleLogs = sinon.stub()
-  const onSetSplitLayout = sinon.stub()
-  const onSetFullLayout = sinon.stub()
-  const onStopCompilation = sinon.stub()
-
-  function renderPreviewToolbar(
-    compilerState = {},
-    logState = {},
-    showLogs = false,
-    splitLayout = true
-  ) {
-    render(
-      <PreviewToolbar
-        compilerState={{
-          autoCompileHasChanges: true,
-          isAutoCompileOn: true,
-          isClearingCache: false,
-          isCompiling: false,
-          isDraftModeOn: false,
-          isSyntaxCheckOn: false,
-          logEntries: {},
-          ...compilerState,
-        }}
-        logsState={{ nErrors: 0, nWarnings: 0, ...logState }}
-        onRecompile={onRecompile}
-        onRecompileFromScratch={onRecompileFromScratch}
-        onRunSyntaxCheckNow={onRunSyntaxCheckNow}
-        onSetAutoCompile={onSetAutoCompile}
-        onSetDraftMode={onSetDraftMode}
-        onSetSyntaxCheck={onSetSyntaxCheck}
-        onToggleLogs={onToggleLogs}
-        outputFiles={[]}
-        pdfDownloadUrl="/download-pdf-url"
-        showLogs={showLogs}
-        splitLayout={splitLayout}
-        onSetSplitLayout={onSetSplitLayout}
-        onSetFullLayout={onSetFullLayout}
-        onStopCompilation={onStopCompilation}
-      />
-    )
-  }
-
-  it('renders the toolbar', function () {
-    renderPreviewToolbar()
-    screen.getByText('Recompile')
-    screen.getByText('Download PDF')
-    screen.getByText('View logs')
-  })
-
-  it('all toolbar items have "toolbar-item" class and text has "toolbar-text"', function () {
-    renderPreviewToolbar()
-    const toolbar = screen.getByTestId('toolbar-preview')
-    for (const toolbarSection of toolbar.children) {
-      for (const toolbarItem of toolbarSection.children) {
-        expect(toolbarItem.className).to.contain('toolbar-item')
-        for (const parts of toolbarItem.children) {
-          for (const part of parts.children) {
-            if (part.nodeName !== 'LI' && part.textContent) {
-              expect(part.className).to.contain('toolbar-text')
-            }
-          }
-        }
-      }
-    }
-  })
-
-  it('renders a full-screen button with a tooltip when when in split-screen mode', function () {
-    renderPreviewToolbar()
-    const btn = screen.getByLabelText('Full screen')
-    fireEvent.click(btn)
-    expect(onSetFullLayout).to.have.been.calledOnce
-    fireEvent.mouseOver(btn)
-    screen.getByRole('tooltip', { name: 'Full screen' })
-  })
-
-  it('renders a split-screen button with a tooltip when when in full-screen mode', function () {
-    renderPreviewToolbar({}, {}, false, false)
-    const btn = screen.getByLabelText('Split screen')
-    fireEvent.click(btn)
-    expect(onSetSplitLayout).to.have.been.calledOnce
-    fireEvent.mouseOver(btn)
-    screen.getByRole('tooltip', { name: 'Split screen' })
-  })
-})

services/web/test/frontend/features/word-count-modal/components/word-count-modal.test.js

@@ -16,6 +16,10 @@ describe('<WordCountModal />', function () {
   }
 
   it('renders the translated modal title', async function () {
+    fetchMock.get('express:/project/:projectId/wordcount', () => {
+      return { status: 200, body: { texcount: { messages: 'This is a test' } } }
+    })
+
     const handleHide = sinon.stub()
 
     renderWithEditorContext(

services/web/test/unit/src/Project/ProjectControllerTests.js

@@ -1397,48 +1397,6 @@ describe('ProjectController', function () {
     })
 
     describe('feature flags', function () {
-      describe('showNewPdfPreview', function () {
-        it('should be false by default', function (done) {
-          this.res.render = (pageName, opts) => {
-            expect(opts.showNewPdfPreview).to.be.false
-            done()
-          }
-          this.ProjectController.loadEditor(this.req, this.res)
-        })
-
-        it('should be true when ?new_pdf_preview=true ', function (done) {
-          this.res.render = (pageName, opts) => {
-            expect(opts.showNewPdfPreview).to.be.true
-            done()
-          }
-          this.req.query.new_pdf_preview = 'true'
-          this.ProjectController.loadEditor(this.req, this.res)
-        })
-
-        it('should be true when the react-pdf-preview-rollout split test is enabled', function (done) {
-          this.res.render = (pageName, opts) => {
-            expect(opts.showNewPdfPreview).to.be.true
-            done()
-          }
-          this.SplitTestHandler.getAssignment
-            .withArgs(this.req, 'react-pdf-preview-rollout')
-            .yields(null, { variant: 'react-pdf-preview' })
-          this.ProjectController.loadEditor(this.req, this.res)
-        })
-
-        it('should be false when when ?new_pdf_preview=false and the split test is enabled', function (done) {
-          this.res.render = (pageName, opts) => {
-            expect(opts.showNewPdfPreview).to.be.false
-            done()
-          }
-          this.SplitTestHandler.getAssignment
-            .withArgs(this.req, 'react-pdf-preview-rollout')
-            .yields(null, { variant: 'react-pdf-preview' })
-          this.req.query.new_pdf_preview = 'false'
-          this.ProjectController.loadEditor(this.req, this.res)
-        })
-      })
-
       describe('showPdfDetach', function () {
         describe('showPdfDetach=false', function () {
           it('should be false by default', function (done) {
@@ -1449,16 +1407,6 @@ describe('ProjectController', function () {
             this.ProjectController.loadEditor(this.req, this.res)
           })
 
-          it('should be false by default, even when ?new_pdf_preview=true', function (done) {
-            this.res.render = (pageName, opts) => {
-              expect(opts.showPdfDetach).to.be.false
-              expect(opts.showNewPdfPreview).to.be.true
-              done()
-            }
-            this.req.query.new_pdf_preview = 'true'
-            this.ProjectController.loadEditor(this.req, this.res)
-          })
-
           it('should be false when the split test is enabled and ?pdf_detach=false', function (done) {
             this.res.render = (pageName, opts) => {
               expect(opts.showPdfDetach).to.be.false
@@ -1473,20 +1421,18 @@ describe('ProjectController', function () {
         })
 
         describe('showPdfDetach=true', function () {
-          it('should be true when ?pdf_detach=true, and set showNewPdfPreview as true ', function (done) {
+          it('should be true when ?pdf_detach=true', function (done) {
             this.res.render = (pageName, opts) => {
               expect(opts.showPdfDetach).to.be.true
-              expect(opts.showNewPdfPreview).to.be.true
               done()
             }
             this.req.query.pdf_detach = 'true'
             this.ProjectController.loadEditor(this.req, this.res)
           })
 
-          it('should be true for alpha group, and set showNewPdfPreview as true', function (done) {
+          it('should be true for alpha group', function (done) {
             this.res.render = (pageName, opts) => {
               expect(opts.showPdfDetach).to.be.true
-              expect(opts.showNewPdfPreview).to.be.true
               done()
             }
             this.SplitTestHandler.getAssignment