390 lines
13 KiB
JavaScript
390 lines
13 KiB
JavaScript
// Inlined after the bundled pdf.js module by scripts/build-pdf.mjs. pdf.js resolves its worker
|
|
// through globalThis.pdfjsWorker, which the bundled worker module installs, so the worker runs on
|
|
// the main thread and this page spawns no Worker, fetches nothing and touches no file.
|
|
;(() => {
|
|
const MAX_BASE64_CHARS = Math.ceil((16 * 1024 * 1024) / 3) * 4
|
|
const MAX_CANVAS_PIXELS = 4000000
|
|
const MAX_CANVAS_DIMENSION = 8192
|
|
const MAX_RATIO = 2
|
|
const MAX_TEXT_ITEMS = 5000
|
|
const MIN_ZOOM = 0.25
|
|
const MAX_ZOOM = 8
|
|
/** Must match the #pdf-page margin in the generated page. */
|
|
const PAGE_MARGIN = 8
|
|
const RESIZE_DEBOUNCE_MS = 120
|
|
const BASE64 = /^[A-Za-z0-9+/]+={0,2}$/
|
|
|
|
if (typeof getDocument !== 'function' || typeof globalThis.pdfjsWorker?.WorkerMessageHandler?.setup !== 'function') {
|
|
throw new Error('The bundled pdf.js module is incomplete.')
|
|
}
|
|
|
|
const rootEl = document.getElementById('pdf-root')
|
|
const pageEl = document.getElementById('pdf-page')
|
|
const canvasEl = document.getElementById('pdf-canvas')
|
|
const textEl = document.getElementById('pdf-text')
|
|
const context = canvasEl.getContext('2d', { alpha: false })
|
|
|
|
const state = { status: 'idle', page: 0, pages: 0, zoom: 1, scale: 0, error: null }
|
|
window.pdfState = state
|
|
|
|
let session = null
|
|
let chunks = []
|
|
let chunkLength = 0
|
|
let beginToken = 0
|
|
let loadToken = 0
|
|
let pageToken = 0
|
|
let renderToken = 0
|
|
let loadingTask = null
|
|
let doc = null
|
|
let current = null
|
|
let pageNumber = 0
|
|
let pageCount = 0
|
|
let zoom = 1
|
|
let activeRender = null
|
|
let resizeTimer = 0
|
|
let lastWidth = 0
|
|
let disposed = false
|
|
|
|
const clamp = (value, min, max) => Math.min(Math.max(value, min), max)
|
|
const send = value => {
|
|
try { window.ReactNativeWebView.postMessage(JSON.stringify(value)) } catch { /* No bridge outside the app. */ }
|
|
}
|
|
const errorCode = error => {
|
|
const name = error?.name
|
|
if (name === 'PasswordException') return 'password'
|
|
if (name === 'InvalidPDFException') return 'invalid'
|
|
return 'failed'
|
|
}
|
|
const dropChunks = () => {
|
|
chunks = []
|
|
chunkLength = 0
|
|
}
|
|
const abortTask = async () => {
|
|
const task = loadingTask
|
|
loadingTask = null
|
|
if (task === null) return
|
|
try { await task.destroy() } catch { /* Already settled or destroyed. */ }
|
|
}
|
|
const fail = code => {
|
|
void abortTask()
|
|
dropChunks()
|
|
state.status = 'error'
|
|
state.error = code
|
|
send({ type: 'error', code, id: session })
|
|
}
|
|
|
|
const cancelRender = async () => {
|
|
const task = activeRender
|
|
activeRender = null
|
|
if (task === null) return
|
|
try { task.cancel() } catch { /* Already settled. */ }
|
|
try { await task.promise } catch { /* Reported by the render call that owns the token. */ }
|
|
}
|
|
|
|
const releasePage = () => {
|
|
const previous = current
|
|
current = null
|
|
textEl.replaceChildren()
|
|
canvasEl.width = 1
|
|
canvasEl.height = 1
|
|
try { previous?.cleanup() } catch { /* The document may already be destroyed. */ }
|
|
}
|
|
|
|
const reset = async () => {
|
|
renderToken += 1
|
|
pageToken += 1
|
|
loadToken += 1
|
|
session = null
|
|
dropChunks()
|
|
await cancelRender()
|
|
releasePage()
|
|
const previous = doc
|
|
doc = null
|
|
pageNumber = 0
|
|
pageCount = 0
|
|
zoom = 1
|
|
state.status = 'idle'
|
|
state.page = 0
|
|
state.pages = 0
|
|
state.zoom = 1
|
|
state.scale = 0
|
|
state.error = null
|
|
await abortTask()
|
|
if (previous !== null) {
|
|
try { await previous.destroy() } catch { /* Superseded loads own their own teardown. */ }
|
|
}
|
|
}
|
|
|
|
const drawText = async (target, scale, mine) => {
|
|
try {
|
|
const content = await target.getTextContent()
|
|
if (mine !== renderToken) return
|
|
const items = content?.items
|
|
if (!Array.isArray(items) || items.length > MAX_TEXT_ITEMS) return
|
|
const viewport = target.getViewport({ scale })
|
|
const fragment = document.createDocumentFragment()
|
|
for (const item of items) {
|
|
if (typeof item?.str !== 'string' || item.str.length === 0) {
|
|
if (item?.hasEOL === true) fragment.append(document.createElement('br'))
|
|
continue
|
|
}
|
|
const box = Util.transform(viewport.transform, item.transform)
|
|
const height = Math.hypot(box[2], box[3])
|
|
if (!Number.isFinite(height) || height <= 0) continue
|
|
const span = document.createElement('span')
|
|
span.textContent = item.str
|
|
span.style.left = `${box[4]}px`
|
|
span.style.top = `${box[5] - height * 0.85}px`
|
|
span.style.fontSize = `${height}px`
|
|
span.style.fontFamily = content.styles?.[item.fontName]?.fontFamily ?? 'sans-serif'
|
|
if (typeof item.dir === 'string' && item.dir !== 'auto') span.dir = item.dir
|
|
fragment.append(span)
|
|
if (item.hasEOL === true) fragment.append(document.createElement('br'))
|
|
}
|
|
textEl.replaceChildren(fragment)
|
|
} catch { /* The canvas already shows the page; a missing text overlay is not a render failure. */ }
|
|
}
|
|
|
|
const render = async () => {
|
|
const mine = ++renderToken
|
|
let task = null
|
|
try {
|
|
await cancelRender()
|
|
if (disposed || mine !== renderToken || current === null || context === null) return
|
|
const base = current.getViewport({ scale: 1 })
|
|
if (!Number.isFinite(base.width) || !Number.isFinite(base.height) || base.width <= 0 || base.height <= 0) {
|
|
throw new Error('The page has no usable size.')
|
|
}
|
|
const available = Math.max(64, rootEl.clientWidth - 2 * PAGE_MARGIN)
|
|
const cssScale = Math.min(
|
|
zoom * available / base.width,
|
|
MAX_CANVAS_DIMENSION / base.width,
|
|
MAX_CANVAS_DIMENSION / base.height,
|
|
)
|
|
const width = Math.max(1, base.width * cssScale)
|
|
const height = Math.max(1, base.height * cssScale)
|
|
const deviceScale = Math.min(
|
|
window.devicePixelRatio || 1,
|
|
MAX_RATIO,
|
|
Math.sqrt(MAX_CANVAS_PIXELS / (width * height)),
|
|
MAX_CANVAS_DIMENSION / width,
|
|
MAX_CANVAS_DIMENSION / height,
|
|
)
|
|
if (!Number.isFinite(deviceScale) || deviceScale <= 0) throw new Error('The page cannot be scaled.')
|
|
const viewport = current.getViewport({ scale: cssScale * deviceScale })
|
|
canvasEl.width = clamp(Math.floor(viewport.width), 1, MAX_CANVAS_DIMENSION)
|
|
canvasEl.height = clamp(Math.floor(viewport.height), 1, MAX_CANVAS_DIMENSION)
|
|
pageEl.style.width = `${width}px`
|
|
pageEl.style.height = `${height}px`
|
|
textEl.replaceChildren()
|
|
state.scale = cssScale
|
|
task = current.render({
|
|
canvasContext: context,
|
|
viewport,
|
|
annotationMode: AnnotationMode.DISABLE,
|
|
background: '#ffffff',
|
|
})
|
|
activeRender = task
|
|
await task.promise
|
|
if (disposed || mine !== renderToken) return
|
|
await drawText(current, cssScale, mine)
|
|
if (disposed || mine !== renderToken) return
|
|
state.status = 'rendered'
|
|
state.page = current.pageNumber
|
|
state.pages = pageCount
|
|
state.zoom = zoom
|
|
state.error = null
|
|
send({ type: 'rendered', id: session, page: current.pageNumber, pages: pageCount, zoom })
|
|
} catch (error) {
|
|
if (disposed || mine !== renderToken || error?.name === 'RenderingCancelledException') return
|
|
fail(errorCode(error))
|
|
} finally {
|
|
if (activeRender === task) activeRender = null
|
|
}
|
|
}
|
|
|
|
const goToPage = async target => {
|
|
const owner = doc
|
|
const mine = ++pageToken
|
|
renderToken += 1
|
|
// The requested page is recorded first so a newer request can never be undone by a stale one.
|
|
pageNumber = target
|
|
await cancelRender()
|
|
if (disposed || owner === null || mine !== pageToken || doc !== owner) return
|
|
releasePage()
|
|
let next
|
|
try {
|
|
next = await owner.getPage(target)
|
|
} catch (error) {
|
|
if (!disposed && mine === pageToken && doc === owner) fail(errorCode(error))
|
|
return
|
|
}
|
|
if (disposed || mine !== pageToken || doc !== owner) {
|
|
try { next.cleanup() } catch { /* Owned by a newer document now. */ }
|
|
return
|
|
}
|
|
current = next
|
|
await render()
|
|
}
|
|
|
|
const load = async value => {
|
|
const mine = ++loadToken
|
|
let reported = false
|
|
const stop = code => {
|
|
if (reported || disposed || mine !== loadToken) return
|
|
reported = true
|
|
fail(code)
|
|
}
|
|
if (typeof value !== 'string' || value.length === 0) { stop('invalid'); return }
|
|
if (value.length > MAX_BASE64_CHARS) { stop('tooLarge'); return }
|
|
if (!BASE64.test(value)) { stop('invalid'); return }
|
|
await abortTask()
|
|
if (disposed || mine !== loadToken) return
|
|
let bytes
|
|
try {
|
|
const binary = atob(value)
|
|
bytes = new Uint8Array(binary.length)
|
|
for (let index = 0; index < binary.length; index++) bytes[index] = binary.charCodeAt(index)
|
|
} catch { stop('invalid'); return }
|
|
let task
|
|
try {
|
|
task = getDocument({
|
|
data: bytes,
|
|
/** Tooling stays quiet: the page silences the console, so failures travel as messages. */
|
|
verbosity: VerbosityLevel.ERRORS,
|
|
/** Every byte is in memory; no range, stream, fetch or wasm path may reach out. */
|
|
disableAutoFetch: true,
|
|
disableRange: true,
|
|
disableStream: true,
|
|
useWorkerFetch: false,
|
|
useWasm: false,
|
|
useSystemFonts: true,
|
|
stopAtErrors: false,
|
|
enableXfa: false,
|
|
enableHWA: false,
|
|
enableWebGPU: false,
|
|
canvasMaxAreaInBytes: MAX_CANVAS_PIXELS * 4,
|
|
})
|
|
} catch { stop('failed'); return }
|
|
loadingTask = task
|
|
/** Encrypted documents have no password prompt here, so they fail closed. */
|
|
task.onPassword = () => { stop('password') }
|
|
let loaded
|
|
try {
|
|
loaded = await task.promise
|
|
} catch (error) {
|
|
stop(errorCode(error))
|
|
return
|
|
} finally {
|
|
if (loadingTask === task) loadingTask = null
|
|
}
|
|
if (disposed || mine !== loadToken) {
|
|
try { await loaded.destroy() } catch { /* Superseded loads own their own teardown. */ }
|
|
return
|
|
}
|
|
doc = loaded
|
|
pageCount = loaded.numPages
|
|
if (pageCount < 1) { stop('invalid'); return }
|
|
pageNumber = 1
|
|
zoom = 1
|
|
let next
|
|
try {
|
|
next = await loaded.getPage(1)
|
|
} catch (error) {
|
|
stop(errorCode(error))
|
|
return
|
|
}
|
|
if (disposed || mine !== loadToken) {
|
|
try { next.cleanup() } catch { /* Superseded loads own their own teardown. */ }
|
|
return
|
|
}
|
|
current = next
|
|
await render()
|
|
}
|
|
|
|
const begin = async id => {
|
|
const mine = ++beginToken
|
|
await reset()
|
|
if (disposed || mine !== beginToken) return
|
|
session = typeof id === 'string' ? id : null
|
|
dropChunks()
|
|
state.status = 'loading'
|
|
state.error = null
|
|
state.page = 0
|
|
state.pages = 0
|
|
state.zoom = 1
|
|
state.scale = 0
|
|
send({ type: 'loading', id: session })
|
|
send({ type: 'ack', id: session, index: 0 })
|
|
}
|
|
|
|
const append = (id, chunk) => {
|
|
if (session === null || id !== session) return
|
|
if (typeof chunk !== 'string' || chunk.length === 0) { fail('invalid'); return }
|
|
if (chunkLength + chunk.length > MAX_BASE64_CHARS) { fail('tooLarge'); return }
|
|
chunks.push(chunk)
|
|
chunkLength += chunk.length
|
|
send({ type: 'ack', id: session, index: chunks.length })
|
|
}
|
|
|
|
const finish = async id => {
|
|
if (session === null || id !== session) return
|
|
const value = chunks.join('')
|
|
dropChunks()
|
|
await load(value)
|
|
}
|
|
|
|
const onResize = () => {
|
|
const width = rootEl.clientWidth
|
|
if (Math.abs(width - lastWidth) < 1) return
|
|
lastWidth = width
|
|
if (resizeTimer !== 0) clearTimeout(resizeTimer)
|
|
resizeTimer = setTimeout(() => {
|
|
resizeTimer = 0
|
|
if (doc !== null) void render()
|
|
}, RESIZE_DEBOUNCE_MS)
|
|
}
|
|
|
|
window.beginPdf = id => { void begin(id) }
|
|
window.appendPdfChunk = (id, chunk) => { append(id, chunk) }
|
|
window.finishPdf = id => { void finish(id) }
|
|
window.loadPdf = async base64 => {
|
|
await begin('local')
|
|
append('local', base64)
|
|
await finish('local')
|
|
}
|
|
window.showPage = value => {
|
|
const target = Math.floor(Number(value))
|
|
if (!Number.isFinite(target) || doc === null || pageCount < 1) return
|
|
const next = clamp(target, 1, pageCount)
|
|
if (next === pageNumber && current !== null) {
|
|
rootEl.scrollTo(0, 0)
|
|
return
|
|
}
|
|
void goToPage(next)
|
|
}
|
|
window.zoomPdf = value => {
|
|
const delta = Number(value)
|
|
if (!Number.isFinite(delta) || doc === null) return
|
|
zoom = clamp(Math.round(zoom * (1 + delta) * 1000) / 1000, MIN_ZOOM, MAX_ZOOM)
|
|
void render()
|
|
}
|
|
|
|
const observer = new ResizeObserver(onResize)
|
|
observer.observe(rootEl)
|
|
window.addEventListener('resize', onResize)
|
|
window.addEventListener('pagehide', () => {
|
|
disposed = true
|
|
if (resizeTimer !== 0) {
|
|
clearTimeout(resizeTimer)
|
|
resizeTimer = 0
|
|
}
|
|
observer.disconnect()
|
|
void reset()
|
|
})
|
|
|
|
lastWidth = rootEl.clientWidth
|
|
state.status = 'ready'
|
|
send({ type: 'ready' })
|
|
})()
|