(() => {
const connection = navigator.connection || {}
const previewConcurrency =
connection.saveData || /(^|-)2g$/.test(connection.effectiveType || "")
? 1
: 2
const previewQueue = []
const previewControllers = new Set()
let activePreviews = 0
let previewsStopped = false
const scheduleIdle = callback => {
if ("requestIdleCallback" in window) {
window.requestIdleCallback(callback, { timeout: 1200 })
} else {
window.setTimeout(callback, 32)
}
}
const runPreviewQueue = () => {
if (
previewsStopped ||
document.visibilityState === "hidden" ||
activePreviews >= previewConcurrency ||
!previewQueue.length
) return
const task = previewQueue.shift()
activePreviews++
scheduleIdle(async () => {
try {
if (!previewsStopped) await task()
} finally {
activePreviews--
runPreviewQueue()
}
})
if (activePreviews < previewConcurrency) runPreviewQueue()
}
const enqueuePreview = task => {
if (previewsStopped) return
previewQueue.push(task)
runPreviewQueue()
}
const renderExcalidrawThumbnail = async canvas => {
const controller = new AbortController()
previewControllers.add(controller)
try {
const response = await fetch(canvas.dataset.previewSrc, {
credentials: "same-origin",
cache: "force-cache",
signal: controller.signal,
headers: { "X-PagesWiki-Priority": "background" }
})
if (!response.ok) return
const scene = await response.json()
const elements = (scene.elements || []).filter(element => !element.isDeleted)
if (!elements.length) return
const width = canvas.clientWidth || 160
const height = canvas.clientHeight || 112
const ratio = window.devicePixelRatio || 1
canvas.width = Math.round(width * ratio)
canvas.height = Math.round(height * ratio)
const context = canvas.getContext("2d")
context.scale(ratio, ratio)
const minX = Math.min(...elements.map(element => element.x || 0))
const minY = Math.min(...elements.map(element => element.y || 0))
const maxX = Math.max(...elements.map(element => (element.x || 0) + Math.abs(element.width || 1)))
const maxY = Math.max(...elements.map(element => (element.y || 0) + Math.abs(element.height || 1)))
const scale = Math.min((width - 12) / Math.max(1, maxX - minX), (height - 12) / Math.max(1, maxY - minY))
context.translate(6 - minX * scale, 6 - minY * scale)
context.scale(scale, scale)
context.lineWidth = 1.5 / Math.max(scale, .1)
elements.slice(0, 500).forEach(element => {
const x = element.x || 0
const y = element.y || 0
const w = element.width || 0
const h = element.height || 0
context.strokeStyle = element.strokeColor || "#555"
context.fillStyle = element.backgroundColor && element.backgroundColor !== "transparent"
? element.backgroundColor
: "transparent"
context.beginPath()
if (element.type === "ellipse") {
context.ellipse(x + w / 2, y + h / 2, Math.abs(w / 2), Math.abs(h / 2), 0, 0, Math.PI * 2)
} else if (element.type === "line" || element.type === "arrow") {
const points = element.points || [[0, 0], [w, h]]
points.forEach((point, index) => {
if (index) context.lineTo(x + point[0], y + point[1])
else context.moveTo(x + point[0], y + point[1])
})
} else if (element.type === "text") {
context.font = `${element.fontSize || 20}px sans-serif`
context.fillStyle = element.strokeColor || "#555"
context.fillText((element.text || "").slice(0, 80), x, y + (element.fontSize || 20))
return
} else {
context.rect(x, y, w, h)
}
if (context.fillStyle !== "transparent") context.fill()
context.stroke()
})
canvas.closest(".children-preview")
?.classList.replace("children-preview-pending", "children-preview-ready")
} catch (_) {
// The format icon and EX badge remain as the safe fallback.
} finally {
previewControllers.delete(controller)
}
}
const initializeExcalidrawViewer = viewer => {
if (viewer.dataset.excalidrawInitialized) return
viewer.dataset.excalidrawInitialized = "true"
const canvas = viewer.querySelector("[data-excalidraw-canvas]")
const source = viewer.querySelector("[data-excalidraw-source]")
if (!canvas || !source) return
let scene
try {
scene = JSON.parse(source.value)
} catch (_) {
return
}
const elements = (scene.elements || []).filter(element =>
!element.isDeleted && Number.isFinite(element.x) && Number.isFinite(element.y)
)
const context = canvas.getContext("2d")
if (!context) return
const camera = { x: 0, y: 0, scale: 1 }
let dragging = false
let previousX = 0
let previousY = 0
const elementBounds = element => {
const points = Array.isArray(element.points) ? element.points : []
const width = Math.abs(Number(element.width) || 0)
const height = Math.abs(Number(element.height) || 0)
let minPointX = 0
let minPointY = 0
let maxPointX = width
let maxPointY = height
points.forEach(point => {
const x = Number(point?.[0]) || 0
const y = Number(point?.[1]) || 0
minPointX = Math.min(minPointX, x)
minPointY = Math.min(minPointY, y)
maxPointX = Math.max(maxPointX, x)
maxPointY = Math.max(maxPointY, y)
})
return {
minX: (Number(element.x) || 0) + minPointX,
minY: (Number(element.y) || 0) + minPointY,
maxX: (Number(element.x) || 0) + maxPointX,
maxY: (Number(element.y) || 0) + maxPointY
}
}
const bounds = () => {
if (!elements.length) return { minX: 0, minY: 0, maxX: 1, maxY: 1 }
const boxes = elements.map(elementBounds)
return {
minX: Math.min(...boxes.map(box => box.minX)),
minY: Math.min(...boxes.map(box => box.minY)),
maxX: Math.max(...boxes.map(box => box.maxX)),
maxY: Math.max(...boxes.map(box => box.maxY))
}
}
const drawElement = element => {
const x = Number(element.x) || 0
const y = Number(element.y) || 0
const width = Number(element.width) || 0
const height = Number(element.height) || 0
const stroke = element.strokeColor || "#1b1b1f"
const fill = element.backgroundColor || "transparent"
context.save()
context.globalAlpha = Math.max(0, Math.min(1, Number(element.opacity ?? 100) / 100))
context.strokeStyle = stroke
context.fillStyle = fill
context.lineWidth = Math.max(1, Number(element.strokeWidth) || 1) / camera.scale
context.lineCap = "round"
context.lineJoin = "round"
context.beginPath()
if (element.type === "text") {
const size = Math.max(4, Number(element.fontSize) || 20)
context.fillStyle = stroke
context.font = `${size}px sans-serif`
context.textBaseline = "top"
String(element.text || "").split("\n").slice(0, 200).forEach((line, index) => {
context.fillText(line, x, y + index * (Number(element.lineHeight) || 1.25) * size)
})
context.restore()
return
}
if (element.type === "ellipse") {
context.ellipse(x + width / 2, y + height / 2, Math.abs(width / 2), Math.abs(height / 2), 0, 0, Math.PI * 2)
} else if (element.type === "diamond") {
context.moveTo(x + width / 2, y)
context.lineTo(x + width, y + height / 2)
context.lineTo(x + width / 2, y + height)
context.lineTo(x, y + height / 2)
context.closePath()
} else if (["line", "arrow", "freedraw"].includes(element.type)) {
const points = Array.isArray(element.points) ? element.points : [[0, 0], [width, height]]
points.forEach((point, index) => {
const px = x + (Number(point?.[0]) || 0)
const py = y + (Number(point?.[1]) || 0)
if (index) context.lineTo(px, py)
else context.moveTo(px, py)
})
} else {
context.rect(x, y, width, height)
}
if (fill !== "transparent" && !["line", "arrow", "freedraw"].includes(element.type)) context.fill()
context.stroke()
context.restore()
}
const render = () => {
const ratio = window.devicePixelRatio || 1
const width = Math.max(1, canvas.clientWidth)
const height = Math.max(1, canvas.clientHeight)
const pixelWidth = Math.round(width * ratio)
const pixelHeight = Math.round(height * ratio)
if (canvas.width !== pixelWidth || canvas.height !== pixelHeight) {
canvas.width = pixelWidth
canvas.height = pixelHeight
}
context.setTransform(ratio, 0, 0, ratio, 0, 0)
context.clearRect(0, 0, width, height)
context.fillStyle = scene.appState?.viewBackgroundColor || "#ffffff"
context.fillRect(0, 0, width, height)
context.translate(camera.x, camera.y)
context.scale(camera.scale, camera.scale)
elements.forEach(drawElement)
}
const fit = () => {
const box = bounds()
const width = Math.max(1, canvas.clientWidth)
const height = Math.max(1, canvas.clientHeight)
const sceneWidth = Math.max(1, box.maxX - box.minX)
const sceneHeight = Math.max(1, box.maxY - box.minY)
camera.scale = Math.max(.02, Math.min(20, Math.min((width - 48) / sceneWidth, (height - 48) / sceneHeight)))
camera.x = (width - sceneWidth * camera.scale) / 2 - box.minX * camera.scale
camera.y = (height - sceneHeight * camera.scale) / 2 - box.minY * camera.scale
render()
}
canvas.addEventListener("pointerdown", event => {
dragging = true
previousX = event.clientX
previousY = event.clientY
canvas.setPointerCapture(event.pointerId)
})
canvas.addEventListener("pointermove", event => {
if (!dragging) return
camera.x += event.clientX - previousX
camera.y += event.clientY - previousY
previousX = event.clientX
previousY = event.clientY
render()
})
canvas.addEventListener("pointerup", () => { dragging = false })
canvas.addEventListener("pointercancel", () => { dragging = false })
canvas.addEventListener("wheel", event => {
event.preventDefault()
const rect = canvas.getBoundingClientRect()
const x = event.clientX - rect.left
const y = event.clientY - rect.top
const next = Math.max(.02, Math.min(20, camera.scale * Math.exp(-event.deltaY * .0015)))
camera.x = x - (x - camera.x) * next / camera.scale
camera.y = y - (y - camera.y) * next / camera.scale
camera.scale = next
render()
}, { passive: false })
viewer.querySelector("[data-excalidraw-fit]")?.addEventListener("click", fit)
new ResizeObserver(render).observe(canvas)
requestAnimationFrame(fit)
}
const activatePreview = async element => {
if (element.dataset.previewLoaded) return
element.dataset.previewLoaded = "true"
const kind = element.dataset.previewKind
if (kind === "excalidraw") {
await renderExcalidrawThumbnail(element)
return
}
await new Promise(resolve => {
const eventName = kind === "video" ? "loadeddata" : "load"
const done = () => {
window.clearTimeout(timeout)
element.closest(".children-preview")
?.classList.replace("children-preview-pending", "children-preview-ready")
resolve()
}
const timeout = window.setTimeout(resolve, 30000)
element.addEventListener(eventName, done, { once: true })
element.addEventListener("error", () => {
window.clearTimeout(timeout)
resolve()
}, { once: true })
if (kind === "image") element.fetchPriority = "low"
element.src = element.dataset.previewSrc
if (kind === "video") element.load()
})
}
const previewObserver = new IntersectionObserver(entries => {
entries.forEach(entry => {
if (!entry.isIntersecting) return
previewObserver.unobserve(entry.target)
// Allow the icon grid and labels to paint before media I/O starts.
requestAnimationFrame(() => requestAnimationFrame(() => {
enqueuePreview(() => activatePreview(entry.target))
}))
})
}, { rootMargin: "250px 0px" })
const pollPreviewCache = async placeholder => {
if (previewsStopped || !placeholder.isConnected) return
const controller = new AbortController()
previewControllers.add(controller)
try {
const response = await fetch(placeholder.dataset.previewCache, {
method: "HEAD",
cache: "no-store",
credentials: "same-origin",
signal: controller.signal,
headers: { "X-PagesWiki-Priority": "background" }
})
if (response.ok) {
const image = document.createElement("img")
image.alt = ""
image.dataset.previewKind = "image"
image.dataset.previewSrc = placeholder.dataset.previewCache
const badge = placeholder.dataset.previewBadge
placeholder.replaceChildren(image)
if (badge) {
const label = document.createElement("span")
label.className = "children-preview-badge"
label.textContent = badge
placeholder.append(label)
}
placeholder.classList.remove("children-preview-placeholder")
delete placeholder.dataset.previewCache
previewObserver.observe(image)
return
}
} catch (_) {
if (previewsStopped) return
} finally {
previewControllers.delete(controller)
}
const attempts = Number.parseInt(placeholder.dataset.previewAttempts || "0", 10) + 1
placeholder.dataset.previewAttempts = String(attempts)
if (attempts < 24) {
window.setTimeout(() => enqueuePreview(
() => pollPreviewCache(placeholder)
), Math.min(15000, 2500 + attempts * 500))
}
}
const cacheObserver = new IntersectionObserver(entries => {
entries.forEach(entry => {
if (!entry.isIntersecting) return
cacheObserver.unobserve(entry.target)
enqueuePreview(() => pollPreviewCache(entry.target))
})
}, { rootMargin: "250px 0px" })
document.addEventListener("visibilitychange", () => {
if (document.visibilityState === "visible") runPreviewQueue()
})
window.addEventListener("pagehide", () => {
previewsStopped = true
previewQueue.length = 0
previewControllers.forEach(controller => controller.abort())
document.querySelectorAll("[data-preview-loaded]").forEach(element => {
if ("pause" in element) element.pause()
element.removeAttribute("src")
})
}, { once: true })
const fetchNextChildren = async sentinel => {
if (sentinel.dataset.childrenFetching) return
sentinel.dataset.childrenFetching = "true"
try {
const response = await fetch(sentinel.dataset.childrenNext, {
credentials: "same-origin",
headers: { "X-Requested-With": "PagesWikiChildren" }
})
if (!response.ok) throw new Error(`HTTP ${response.status}`)
const range = document.createRange()
const fragment = range.createContextualFragment(await response.text())
initializeChildren(fragment)
sentinel.replaceWith(fragment)
} catch (error) {
sentinel.dataset.childrenFetching = ""
sentinel.setAttribute("aria-label", error.message)
}
}
const nextObserver = new IntersectionObserver(entries => {
entries.forEach(entry => {
if (!entry.isIntersecting) return
nextObserver.unobserve(entry.target)
fetchNextChildren(entry.target)
})
}, { rootMargin: "800px 0px" })
const initializeChildren = root => {
const previews = []
const sentinels = []
const pendingCaches = []
if (root.matches?.("[data-preview-src]")) previews.push(root)
if (root.matches?.("[data-children-next]")) sentinels.push(root)
if (root.matches?.("[data-preview-cache]")) pendingCaches.push(root)
root.querySelectorAll?.("[data-preview-src]").forEach(item => previews.push(item))
root.querySelectorAll?.("[data-children-next]").forEach(item => sentinels.push(item))
root.querySelectorAll?.("[data-preview-cache]").forEach(item => pendingCaches.push(item))
previews.forEach(preview => previewObserver.observe(preview))
sentinels.forEach(sentinel => nextObserver.observe(sentinel))
pendingCaches.forEach(item => cacheObserver.observe(item))
}
const childrenModeKey = "pageswiki.children.view"
const validChildrenMode = mode =>
mode === "icon" || mode === "detail" || mode === "list"
const currentChildrenMode = () => {
const saved = localStorage.getItem(childrenModeKey)
return validChildrenMode(saved) ? saved : "list"
}
const childrenSource = (container, mode, offset = 0) => {
const query = new URLSearchParams()
query.set("path", container.dataset.childrenPath || location.pathname)
query.set("view", mode)
if (container.dataset.childrenExclude) {
query.set("exclude", container.dataset.childrenExclude)
}
if (offset) query.set("offset", String(offset))
return `/v/children?${query}`
}
const updateChildrenSwitcher = mode => {
const switcher = document.querySelector("[data-children-view-switcher]")
if (!switcher) return
switcher.hidden = !document.querySelector(
"[data-children-src], [data-search-view]"
)
switcher.querySelectorAll("[data-children-view]").forEach(button => {
const active = button.dataset.childrenView === mode
button.classList.toggle("active", active)
button.setAttribute("aria-pressed", String(active))
})
}
const loadChildren = root => {
const containers = []
if (root.matches?.("[data-children-src]")) containers.push(root)
root.querySelectorAll?.("[data-children-src]").forEach(item => containers.push(item))
containers.forEach(async container => {
if (container.dataset.childrenLoading) return
container.dataset.childrenLoading = "true"
const mode = currentChildrenMode()
container.dataset.childrenSrc = childrenSource(container, mode)
updateChildrenSwitcher(mode)
try {
const response = await fetch(container.dataset.childrenSrc, {
credentials: "same-origin",
headers: { "X-Requested-With": "PagesWikiChildren" }
})
if (!response.ok) throw new Error(`HTTP ${response.status}`)
container.innerHTML = await response.text()
initializeChildren(container)
} catch (error) {
container.innerHTML = `
${error.message}
`
} finally {
delete container.dataset.childrenLoading
}
})
}
// Dynamic projections such as the Editor preview must be able to start
// loading immediately instead of depending only on MutationObserver timing.
window.PagesWikiLoadChildren = loadChildren
document.addEventListener("click", event => {
const viewButton = event.target.closest("[data-children-view]")
if (viewButton) {
const mode = viewButton.dataset.childrenView
if (!validChildrenMode(mode)) return
localStorage.setItem(childrenModeKey, mode)
document.querySelectorAll("[data-search-view]").forEach(results => {
results.dataset.searchView = mode
})
document.querySelectorAll("[data-children-src]").forEach(container => {
container.innerHTML = `Loading…
`
container.dataset.childrenSrc = childrenSource(container, mode)
})
updateChildrenSwitcher(mode)
loadChildren(document)
return
}
const entry = event.target.closest(".children-entry")
if (entry && (event.ctrlKey || event.metaKey)) {
event.preventDefault()
entry.classList.toggle("children-selected")
return
}
const menu = document.querySelector("[data-children-context-menu]")
if (menu && !event.target.closest("[data-children-context-menu]")) {
menu.hidden = true
}
})
document.addEventListener("contextmenu", event => {
const entry = event.target.closest(".children-entry")
if (!entry) return
event.preventDefault()
if (!entry.classList.contains("children-selected")) {
document.querySelectorAll(".children-entry.children-selected")
.forEach(item => item.classList.remove("children-selected"))
entry.classList.add("children-selected")
}
const menu = document.querySelector("[data-children-context-menu]")
if (!menu) return
menu.hidden = false
menu.dataset.activePath = entry.dataset.childPath || ""
refreshAdapterActions(menu, menu.dataset.activePath)
const width = menu.offsetWidth
const height = menu.offsetHeight
menu.style.left = `${Math.min(event.clientX, innerWidth - width - 8)}px`
menu.style.top = `${Math.min(event.clientY, innerHeight - height - 8)}px`
})
const selectedChildrenPaths = () => {
const paths = Array.from(new Set(Array.from(
document.querySelectorAll(".children-entry.children-selected")
).map(item => item.dataset.childPath).filter(Boolean))).sort(
(left, right) => left.length - right.length || left.localeCompare(right)
)
// Moving or deleting a selected directory already includes descendants.
return paths.filter((path, index) => !paths.slice(0, index).some(
parent => path.startsWith(`${parent}/`)
))
}
const postJSON = async (url, body) => {
const response = await fetch(url, {
method: "POST",
credentials: "same-origin",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(body)
})
if (!response.ok) throw new Error((await response.text()).trim() || `HTTP ${response.status}`)
}
const pathBasename = path => path.replace(/\/+$/, "").split("/").pop()
const pathDirname = path => {
const clean = path.replace(/\/+$/, "")
return clean.slice(0, clean.lastIndexOf("/")) || "/"
}
const copyBasename = name => {
const dot = name.lastIndexOf(".")
return dot > 0
? `${name.slice(0, dot)} (copy)${name.slice(dot)}`
: `${name} (copy)`
}
const joinSemanticPath = (directory, name) =>
`${directory === "/" ? "" : directory}/${name}`.replace(/\/+/g, "/")
const refreshAdapterActions = async (menu, path) => {
const target = menu.querySelector("[data-adapter-actions]")
const group = menu.querySelector("[data-adapter-group]")
if (!target || !group) return
target.replaceChildren()
group.hidden = true
if (!path || selectedChildrenPaths().length !== 1) return
try {
const response = await fetch(
`/_/api/v1/adapter?path=${encodeURIComponent(path)}`,
{credentials: "same-origin", cache: "no-store"}
)
if (!response.ok) return
const data = await response.json()
for (const action of data.actions || []) {
const link = document.createElement("a")
link.href = action.open_url
link.textContent = action.default ? `★ ${action.name}` : action.name
link.dataset.adapterMode = action.mode
if (action.new_tab) {
link.target = "_blank"
link.rel = "noopener"
}
if (action.mode === "native") link.rel = "external"
target.append(link)
}
group.hidden = !target.children.length
} catch (_) {
group.hidden = true
}
}
document.querySelector("[data-children-open]")?.addEventListener("click", () => {
const paths = selectedChildrenPaths()
if (paths.length === 1) location.href = paths[0]
})
document.querySelector("[data-children-rename]")?.addEventListener("click", async () => {
const menu = document.querySelector("[data-children-context-menu]")
const paths = selectedChildrenPaths()
if (paths.length !== 1) return
const oldPath = paths[0]
const newPath = prompt(menu.dataset.renamePrompt || "New path", oldPath)
if (!newPath || newPath === oldPath) return
try {
await postJSON("/_/api/v1/path/rename", {
old_path: oldPath, new_path: newPath, recursive: true
})
location.reload()
} catch (error) {
alert(`${menu.dataset.operationFailed || "Operation failed"}: ${error.message}`)
}
})
document.querySelector("[data-children-copy]")?.addEventListener("click", () => {
const paths = selectedChildrenPaths()
if (!paths.length) return
localStorage.setItem("pageswiki.fileClipboard", JSON.stringify({
operation: "copy", paths, created_at: Date.now()
}))
})
document.querySelector("[data-children-paste]")?.addEventListener("click", async () => {
const menu = document.querySelector("[data-children-context-menu]")
let clipboard
try {
clipboard = JSON.parse(localStorage.getItem("pageswiki.fileClipboard") || "null")
} catch (_) {
clipboard = null
}
if (!clipboard?.paths?.length) return
const directory = menu.dataset.activePath
? pathDirname(menu.dataset.activePath)
: (menu.dataset.contextPath || "/")
menu.hidden = true
try {
for (const sourcePath of clipboard.paths) {
const basename = pathBasename(sourcePath)
const destinationName = pathDirname(sourcePath) === directory
? copyBasename(basename) : basename
await postJSON("/_/api/v1/path/copy", {
source_path: sourcePath,
destination_path: joinSemanticPath(directory, destinationName),
recursive: true
})
}
location.reload()
} catch (error) {
alert(`${menu.dataset.operationFailed || "Operation failed"}: ${error.message}`)
}
})
document.querySelector("[data-children-move]")?.addEventListener("click", async () => {
const menu = document.querySelector("[data-children-context-menu]")
const paths = selectedChildrenPaths()
if (!paths.length) return
const target = prompt(menu.dataset.movePrompt || "Destination directory", "/")
if (!target) return
const directory = `/${target}`.replace(/\/+/g, "/").replace(/\/$/, "") || "/"
const names = paths.map(path => path.slice(path.lastIndexOf("/") + 1))
if (new Set(names).size !== names.length) {
alert(`${menu.dataset.operationFailed || "Operation failed"}: duplicate destination name`)
return
}
menu.hidden = true
try {
for (const oldPath of paths) {
const basename = oldPath.slice(oldPath.lastIndexOf("/") + 1)
const newPath = directory === "/" ? `/${basename}` : `${directory}/${basename}`
await postJSON("/_/api/v1/path/rename", {
old_path: oldPath,
new_path: newPath,
recursive: true
})
}
location.reload()
} catch (error) {
alert(`${menu.dataset.operationFailed || "Operation failed"}: ${error.message}`)
}
})
document.querySelector("[data-children-delete]")?.addEventListener("click", async () => {
const menu = document.querySelector("[data-children-context-menu]")
const paths = selectedChildrenPaths()
if (!paths.length) return
if (!confirm(menu.dataset.deleteConfirm || "Delete selected paths?")) return
menu.hidden = true
try {
await postJSON("/_/api/v1/path/remove", {
paths,
recursive: true
})
location.reload()
} catch (error) {
alert(`${menu.dataset.operationFailed || "Operation failed"}: ${error.message}`)
}
})
// Server-rendered listings (for example /v/browser) already contain
// preview nodes, so register them before handling async children macros.
initializeChildren(document)
loadChildren(document)
document.querySelectorAll("[data-search-view]").forEach(results => {
results.dataset.searchView = currentChildrenMode()
})
updateChildrenSwitcher(currentChildrenMode())
new MutationObserver(records => {
records.forEach(record => {
record.addedNodes.forEach(node => {
if (node.nodeType === Node.ELEMENT_NODE) loadChildren(node)
})
})
}).observe(document.documentElement, { childList: true, subtree: true })
const formatTime = value => {
if (!Number.isFinite(value)) return "0:00"
const seconds = Math.max(0, Math.floor(value))
const hours = Math.floor(seconds / 3600)
const minutes = Math.floor((seconds % 3600) / 60)
const rest = String(seconds % 60).padStart(2, "0")
return hours
? `${hours}:${String(minutes).padStart(2, "0")}:${rest}`
: `${minutes}:${rest}`
}
document.querySelectorAll("[data-lightbox-open]").forEach(trigger => {
const dialog = trigger.nextElementSibling
if (!dialog || !dialog.matches("[data-lightbox]")) return
trigger.addEventListener("click", () => dialog.showModal())
dialog.querySelector("[data-lightbox-close]")
?.addEventListener("click", () => dialog.close())
dialog.addEventListener("click", event => {
if (event.target === dialog) dialog.close()
})
})
document.querySelectorAll("[data-media-player]").forEach(player => {
const media = player.querySelector("audio, video")
const rate = player.querySelector("[data-playback-rate]")
const time = player.querySelector("[data-media-time]")
if (!media) return
const updateTime = () => {
if (time) {
time.textContent =
`${formatTime(media.currentTime)} / ${formatTime(media.duration)}`
}
}
media.addEventListener("loadedmetadata", updateTime)
media.addEventListener("timeupdate", updateTime)
rate?.addEventListener("change", () => {
media.playbackRate = Number.parseFloat(rate.value) || 1
})
player.querySelector("[data-media-fullscreen]")
?.addEventListener("click", () => {
if (document.fullscreenElement) {
document.exitFullscreen()
} else {
player.requestFullscreen()
}
})
const pip = player.querySelector("[data-media-pip]")
if (!document.pictureInPictureEnabled || !media.requestPictureInPicture) {
pip?.remove()
} else {
pip?.addEventListener("click", async () => {
if (document.pictureInPictureElement) {
await document.exitPictureInPicture()
} else {
await media.requestPictureInPicture()
}
})
}
})
const pluginFrames = Array.from(document.querySelectorAll("[data-excalidraw-plugin]"))
const activateExcalidrawFallback = frame => {
if (frame.dataset.excalidrawFallbackActive) return
frame.dataset.excalidrawFallbackActive = "true"
frame.hidden = true
const fallback = frame.closest("[data-excalidraw-plugin-host]")
?.querySelector("[data-excalidraw-fallback]")
if (!fallback) return
fallback.hidden = false
initializeExcalidrawViewer(fallback)
}
pluginFrames.forEach(frame => {
const timeout = window.setTimeout(() => activateExcalidrawFallback(frame), 15000)
frame.addEventListener("error", () => activateExcalidrawFallback(frame), { once: true })
const receive = event => {
if (event.origin !== window.location.origin || event.source !== frame.contentWindow ||
event.data?.source !== "pageswiki-excalidraw") return
if (event.data.type === "ready") {
window.clearTimeout(timeout)
} else if (event.data.type === "error") {
window.clearTimeout(timeout)
activateExcalidrawFallback(frame)
}
}
window.addEventListener("message", receive)
window.addEventListener("pagehide", () => {
window.clearTimeout(timeout)
window.removeEventListener("message", receive)
}, { once: true })
})
document.querySelectorAll("[data-excalidraw-viewer]:not([data-excalidraw-fallback])")
.forEach(initializeExcalidrawViewer)
const initializeComicViewer = viewer => {
if (viewer.dataset.comicInitialized) return
const pages = Array.from(viewer.querySelectorAll("[data-comic-page]"))
if (!pages.length) return
viewer.dataset.comicInitialized = "true"
const status = viewer.querySelector("[data-comic-status]")
const layoutButton = viewer.querySelector("[data-comic-layout]")
let index = 0
let spread = false
const render = () => {
const count = spread ? 2 : 1
index = Math.max(0, Math.min(index, Math.max(0, pages.length - 1)))
pages.forEach((page, pageIndex) => {
const visible = pageIndex >= index && pageIndex < index + count
page.hidden = !visible
if (visible && !page.src) page.src = page.dataset.src
})
viewer.dataset.layout = spread ? "spread" : "single"
if (status) {
const end = Math.min(pages.length, index + count)
status.textContent = pages.length ? `${index + 1}–${end} / ${pages.length}` : "0 / 0"
}
}
const move = direction => {
index += direction * (spread ? 2 : 1)
render()
}
viewer.querySelector("[data-comic-prev]")
?.addEventListener("click", () => move(-1))
viewer.querySelector("[data-comic-next]")
?.addEventListener("click", () => move(1))
layoutButton?.addEventListener("click", () => {
spread = !spread
layoutButton.textContent = spread
? viewer.dataset.singleLabel || "Single page"
: viewer.dataset.spreadLabel || "Two-page spread"
render()
})
viewer.querySelector("[data-comic-fit]")?.addEventListener("click", async () => {
if (document.fullscreenElement === viewer) {
await document.exitFullscreen()
} else {
await viewer.requestFullscreen()
}
})
document.addEventListener("keydown", event => {
if (!viewer.isConnected || event.altKey || event.ctrlKey || event.metaKey) return
if (event.key === "ArrowLeft") {
event.preventDefault()
move(-1)
} else if (event.key === "ArrowRight") {
event.preventDefault()
move(1)
}
})
render()
}
document.querySelectorAll("[data-comic-viewer]").forEach(initializeComicViewer)
// These are small, authorization-checked metadata reads. Decoders run only
// in the durable scheduler; polling pauses in hidden tabs and has a budget.
const watchMetadata = (element, ready) => {
const endpoint = element.dataset.metadataUrl
if (!endpoint) return
const status = element.querySelector("[data-projection-status]") || element.previousElementSibling?.querySelector("[data-projection-status]")
const retry = element.querySelector("[data-projection-retry]") || element.previousElementSibling?.querySelector("[data-projection-retry]")
const loadingLabel = element.dataset.loadingLabel || "Loading…"
const failedLabel = element.dataset.failedLabel || "Metadata unavailable"
const unavailableLabel = element.dataset.unavailableLabel || failedLabel
let timer, controller, attempts = 0, stopped = false, complete = false
const load = async () => {
window.clearTimeout(timer)
if (stopped || !element.isConnected) return
if (document.visibilityState === "hidden") {
timer = window.setTimeout(load, 5000)
return
}
attempts++
if (retry) { retry.hidden = true; retry.disabled = true }
if (status) status.textContent = loadingLabel
controller?.abort()
controller = new AbortController()
const timeout = window.setTimeout(() => controller.abort(), 15000)
try {
const response = await fetch(endpoint, { credentials: "same-origin", cache: "no-store", signal: controller.signal })
if (!response.headers.get("content-type")?.includes("application/json")) throw new Error(failedLabel)
const data = await response.json()
if (response.status === 202 && data.status === "pending") {
if (attempts >= 60) {
if (retry) { retry.hidden = false; retry.disabled = false }
return
}
const delay = Math.min(10000, Math.max(2000, Number(response.headers.get("Retry-After") || "2") * 1000, attempts * 500))
timer = window.setTimeout(load, delay)
return
}
if (!response.ok || data.status !== "ready") throw new Error(data.status === "unavailable" ? unavailableLabel : failedLabel)
if (status) status.textContent = ""
ready(data, status)
complete = true
} catch (error) {
if (stopped) return
if (status) status.textContent = error.message === unavailableLabel ? unavailableLabel : failedLabel
if (retry) { retry.hidden = false; retry.disabled = false }
} finally {
window.clearTimeout(timeout)
}
}
retry?.addEventListener("click", () => { attempts = 0; load() })
window.addEventListener("pagehide", () => { stopped = true; controller?.abort(); window.clearTimeout(timer) })
window.addEventListener("pageshow", event => {
if (event.persisted && !complete) { stopped = false; attempts = 0; load() }
})
load()
}
document.querySelectorAll("[data-archive-metadata]").forEach(viewer => {
if (viewer.dataset.metadataStatus === "ready") return
watchMetadata(viewer, (data, status) => {
const entries = Array.isArray(data.entries) ? data.entries.slice(0, 2000) : []
const table = viewer.querySelector("[data-archive-entries]")
const comic = viewer.querySelector("[data-comic-viewer]")
const pages = comic?.querySelector("[data-comic-pages]")
const fragment = document.createDocumentFragment()
for (const entry of entries) {
let href
try {
const url = new URL(entry.url || "", location.href)
if (url.origin !== location.origin || url.pathname !== "/v/archive") continue
href = url.href
} catch { continue }
if (table) {
const row = document.createElement("tr"), name = document.createElement("td"), size = document.createElement("td")
if (entry.is_dir) name.textContent = entry.name
else { const link = document.createElement("a"); link.href = href; link.textContent = entry.name; name.append(link) }
size.textContent = String(entry.size ?? 0)
row.append(name, size); fragment.append(row)
} else if (pages && entry.is_image) {
const image = document.createElement("img")
image.dataset.comicPage = ""; image.dataset.src = href; image.alt = entry.name; image.hidden = true
fragment.append(image)
}
}
if (table) table.replaceChildren(fragment)
else if (pages) { pages.replaceChildren(fragment); initializeComicViewer(comic) }
viewer.dataset.metadataStatus = "ready"
if (status) status.textContent = data.truncated ? `${entries.length} · ${viewer.dataset.truncatedLabel || "…"}` : entries.length ? "" : "0"
})
})
document.querySelectorAll("[data-pdf-viewer]").forEach(viewer => {
const image = viewer.querySelector("[data-pdf-image]")
const toolbar = viewer.previousElementSibling
const status = toolbar?.querySelector("[data-pdf-status]")
let total = Number.parseInt(viewer.dataset.pages || "0", 10)
let page = 1
const render = () => {
image.src = `/v/pdf-page?rev=${encodeURIComponent(viewer.dataset.revision)}&page=${page}`
if (status) status.textContent = `${page} / ${total || "?"}`
viewer.scrollTo({ top: 0, behavior: "instant" })
}
let retries = 0
image?.addEventListener("error", () => {
if (retries >= 90) return
retries += 1
window.setTimeout(render, 1000)
})
image?.addEventListener("load", () => { retries = 0 })
const move = direction => {
const next = page + direction
if (next < 1 || (total && next > total)) return
page = next
render()
}
toolbar?.querySelector("[data-pdf-prev]")
?.addEventListener("click", () => move(-1))
toolbar?.querySelector("[data-pdf-next]")
?.addEventListener("click", () => move(1))
if (!total) watchMetadata(viewer, data => {
total = Math.max(0, Math.min(10000, Number(data.pdf_pages) || 0))
viewer.dataset.pages = String(total)
if (total && page > total) { page = total; render() }
else if (status) status.textContent = `${page} / ${total || "?"}`
})
})
const escapeJSONText = value => String(value ?? "").replace(/[&<>"']/g, character => ({"&":"&","<":"<",">":">",'"':""","'":"'"}[character]))
document.querySelectorAll("[data-json-viewer]").forEach(viewer => {
const root = viewer.querySelector("[data-json-root]")
const status = viewer.querySelector("[data-json-status]")
const endpoint = viewer.dataset.jsonUrl
if (!root || !endpoint) return
const load = async (container, pointer = "", offset = 0, append = false) => {
const url = new URL(endpoint, location.href)
url.searchParams.set("pointer", pointer);url.searchParams.set("offset", String(offset));url.searchParams.set("limit", "100")
if (!append) container.innerHTML = 'Loading…
'
const response = await fetch(url, {credentials:"same-origin"})
if (!response.ok) throw new Error(await response.text())
const page = await response.json()
if (!append) container.innerHTML = ""
for (const item of page.items || []) {
const row = document.createElement("div");row.className = "json-structure-item json-kind-" + item.kind
if (item.expandable) {
row.innerHTML = '' + escapeJSONText(item.key) + '' + escapeJSONText(item.kind) + ''
const button=row.querySelector("button"),children=row.querySelector(".json-structure-children")
button.addEventListener("click",async()=>{const open=button.getAttribute("aria-expanded")==="true";button.setAttribute("aria-expanded",String(!open));button.textContent=open?"▸":"▾";children.hidden=open;if(!open&&!children.dataset.loaded){children.dataset.loaded="true";try{await load(children,item.path)}catch(error){children.textContent=error.message}}})
} else row.innerHTML = '' + escapeJSONText(item.key) + '' + escapeJSONText(item.preview) + '' + escapeJSONText(item.kind) + ''
container.appendChild(row)
}
if(page.truncated){const more=document.createElement("button");more.type="button";more.className="json-structure-more";more.textContent="Load more";more.addEventListener("click",async()=>{more.remove();await load(container,pointer,page.next_offset,true)});container.appendChild(more)}
if(status)status.textContent=page.kind+(page.truncated?" · bounded":"")
}
load(root).catch(error=>{if(status)status.textContent=error.message})
})
})()