517 lines
30 KiB
JavaScript
517 lines
30 KiB
JavaScript
(function () {
|
||
"use strict";
|
||
// This fixed program runs only in Qt's isolated ApplicationWorld. It adds
|
||
// no DOM nodes, IDs, bridges, document scripts, or host capabilities.
|
||
if (globalThis.__docviewReader) return;
|
||
const MAX_INDEX = 2000;
|
||
let headings = [];
|
||
let options = { fixed: false, rtl: false, publisherStyle: true };
|
||
let originalTypography = null;
|
||
let focusedLink = null;
|
||
let linkOutline = null;
|
||
let restoredRange = null;
|
||
let layoutAnchor = null, resourceRestoreFrame = 0;
|
||
let userScrollPending = false, userScrollFrame = 0;
|
||
let navigationTargets = [], navigationRevision = "";
|
||
let resourceIssues = Object.create(null);
|
||
// Only aggregate directive classes. Never copy blockedURI, sourceFile,
|
||
// originalPolicy or sample into the application or its saved state.
|
||
document.addEventListener("securitypolicyviolation", event => {
|
||
if (!event.isTrusted || event.disposition !== "enforce") return;
|
||
const directive = String(event.effectiveDirective || "").split("-")[0];
|
||
const category = ({img:"image", style:"style", font:"font", script:"script", frame:"frame",
|
||
child:"frame", connect:"connect", form:"form", base:"base", object:"object", media:"media"})[directive] || "other";
|
||
const key = "csp." + category;
|
||
resourceIssues[key] = Math.min(999999, (resourceIssues[key] || 0) + 1);
|
||
});
|
||
|
||
function text(node, limit = 512) {
|
||
return String(node ? node.textContent || "" : "").replace(/\s+/g, " ").trim().slice(0, limit);
|
||
}
|
||
function visible(element) {
|
||
if (!element || !element.isConnected || element.hidden || element.closest("[hidden],[aria-hidden='true']")) return false;
|
||
const style = getComputedStyle(element);
|
||
return style.display !== "none" && style.visibility !== "hidden" && style.visibility !== "collapse" && element.getClientRects().length > 0;
|
||
}
|
||
function axis() {
|
||
const style = getComputedStyle(document.body || document.documentElement);
|
||
const vertical = /^(vertical|sideways)/.test(style.writingMode);
|
||
return { vertical, reverse: vertical && /-rl$/.test(style.writingMode), writingMode: style.writingMode };
|
||
}
|
||
function progression() {
|
||
const root = document.scrollingElement || document.documentElement;
|
||
const a = axis();
|
||
const total = a.vertical ? root.scrollWidth - innerWidth : root.scrollHeight - innerHeight;
|
||
const position = a.vertical ? (a.reverse ? -scrollX : scrollX) : scrollY;
|
||
return total > 0 ? Math.max(0, Math.min(1, position / total)) : 0;
|
||
}
|
||
function setProgression(value) {
|
||
const root = document.scrollingElement || document.documentElement;
|
||
const a = axis();
|
||
const p = Math.max(0, Math.min(1, Number(value) || 0));
|
||
const total = a.vertical ? root.scrollWidth - innerWidth : root.scrollHeight - innerHeight;
|
||
if (a.vertical) scrollTo({ left: Math.max(0, total) * p * (a.reverse ? -1 : 1), top: 0, behavior: "instant" });
|
||
else scrollTo({ left: 0, top: Math.max(0, total) * p, behavior: "instant" });
|
||
}
|
||
function hrefFor(reference, base = document.baseURI) {
|
||
try {
|
||
const url = new URL(reference, base);
|
||
if (url.protocol !== "doc:" || url.host !== location.host || url.username || url.password) return "";
|
||
return url.pathname.replace(/^\//, "") + url.search + url.hash;
|
||
} catch (_) { return ""; }
|
||
}
|
||
function headingIndex() {
|
||
headings = [];
|
||
const nodes = document.querySelectorAll("h1,h2,h3,h4,h5,h6,[role='heading']");
|
||
let truncated = false;
|
||
for (const node of nodes) {
|
||
if (!visible(node)) continue;
|
||
const name = node.localName.toLowerCase();
|
||
const nativeLevel = /^h[1-6]$/.test(name) ? Number(name[1]) : 0;
|
||
const ariaLevel = Number(node.getAttribute("aria-level"));
|
||
const level = nativeLevel || (Number.isInteger(ariaLevel) && ariaLevel > 0 && ariaLevel <= 6 ? ariaLevel : 0);
|
||
if (!level) continue;
|
||
if (headings.length === MAX_INDEX) { truncated = true; break; }
|
||
headings.push({ element: node, level, title: text(node) || "見出し（レベル" + level + "）" });
|
||
}
|
||
return { truncated, rows: headings.map((h, index) => ({ index, title: h.title, level: h.level, depth: h.level - 1,
|
||
href: h.element.id ? hrefFor("#" + encodeURIComponent(h.element.id), location.href) : "", source: "html-heading", precision: "exact" })) };
|
||
}
|
||
function index() {
|
||
const result = headingIndex();
|
||
const outline = [];
|
||
const navs = document.querySelectorAll("[role='doc-toc'],nav");
|
||
for (const nav of navs) {
|
||
// XHTML keeps epub:type in its XML namespace; HTML retains the
|
||
// prefixed attribute name. CSS attribute selectors do not match both.
|
||
const epubType = nav.getAttributeNS("http://www.idpf.org/2007/ops", "type") || nav.getAttribute("epub:type") || "";
|
||
if (nav.getAttribute("role") !== "doc-toc" && !epubType.split(/\s+/).includes("toc")) continue;
|
||
for (const link of nav.querySelectorAll("a[href]")) {
|
||
if (!visible(link) || outline.length >= MAX_INDEX) continue;
|
||
let depth = 0;
|
||
for (let parent = link.parentElement; parent && parent !== nav; parent = parent.parentElement)
|
||
if (parent.localName.toLowerCase() === "ol" || parent.localName.toLowerCase() === "ul") ++depth;
|
||
const href = hrefFor(link.getAttribute("href"));
|
||
outline.push({ title: text(link) || "目次項目", href, depth: Math.max(0, depth - 1), missing: !href, source: "html-toc" });
|
||
}
|
||
}
|
||
return { title: String(document.title || "").slice(0, 4096), headings: result.rows, outline,
|
||
truncated: result.truncated, scriptCount: document.scripts.length,
|
||
fixedViewport: viewport(), writingMode: axis().writingMode };
|
||
}
|
||
function viewport() {
|
||
const element = document.querySelector("meta[name='viewport']");
|
||
const value = element ? element.getAttribute("content") || "" : "";
|
||
const w = /(?:^|[,;\s])width\s*=\s*([0-9.]+)/i.exec(value);
|
||
const h = /(?:^|[,;\s])height\s*=\s*([0-9.]+)/i.exec(value);
|
||
let width = w ? Number(w[1]) : 0, height = h ? Number(h[1]) : 0;
|
||
if ((!width || !height) && document.documentElement.localName === "svg") {
|
||
const box = document.documentElement.viewBox && document.documentElement.viewBox.baseVal;
|
||
if (box) { width = box.width; height = box.height; }
|
||
}
|
||
return width > 0 && height > 0 && width <= 100000 && height <= 100000 ? { width, height } : {};
|
||
}
|
||
function cfiFor(node, offset = 0) {
|
||
const steps = [];
|
||
let target = node;
|
||
if (!target) return "";
|
||
if (target.nodeType === Node.TEXT_NODE) {
|
||
let elements = 0, previousText = 0;
|
||
for (const sibling of target.parentNode.childNodes) {
|
||
if (sibling === target) break;
|
||
if (sibling.nodeType === Node.ELEMENT_NODE) { ++elements; previousText = 0; }
|
||
if (sibling.nodeType === Node.TEXT_NODE) previousText += sibling.length;
|
||
}
|
||
steps.unshift(elements * 2 + 1);
|
||
offset += previousText;
|
||
target = target.parentElement;
|
||
}
|
||
while (target && target !== document.documentElement && steps.length < 128) {
|
||
let order = 1;
|
||
for (let sibling = target.previousElementSibling; sibling; sibling = sibling.previousElementSibling) ++order;
|
||
steps.unshift(order * 2);
|
||
target = target.parentElement;
|
||
}
|
||
return target === document.documentElement ? "epubcfi(/" + steps.join("/") + ":" + Math.max(0, offset) + ")" : "";
|
||
}
|
||
function resolveCfi(cfi) {
|
||
if (typeof cfi !== "string" || cfi.length > 4096 || !/^epubcfi\(.*\)$/.test(cfi)) return null;
|
||
let value = cfi.slice(8, -1);
|
||
if (value.includes("!")) value = value.slice(value.lastIndexOf("!") + 1);
|
||
value = value.replace(/\[(?:\^.|[^\]])*\]/g, "");
|
||
if (!/^\/(?:[1-9][0-9]*\/)*[1-9][0-9]*(?::[0-9]+)?$/.test(value)) return null;
|
||
const parts = value.split(":");
|
||
const steps = parts[0].slice(1).split("/").map(Number);
|
||
if (steps.length > 128) return null;
|
||
let node = document.documentElement;
|
||
let offset = Number(parts[1] || 0);
|
||
for (let i = 0; i < steps.length; ++i) {
|
||
const step = steps[i];
|
||
if (step % 2 === 0) node = node && node.children && node.children[step / 2 - 1];
|
||
else {
|
||
if (!node || i !== steps.length - 1) return null;
|
||
const slot = (step - 1) / 2;
|
||
let elements = 0, found = null;
|
||
for (const child of node.childNodes) {
|
||
if (child.nodeType === Node.ELEMENT_NODE) ++elements;
|
||
else if (child.nodeType === Node.TEXT_NODE && elements === slot) {
|
||
if (offset <= child.length) { found = child; break; }
|
||
offset -= child.length;
|
||
}
|
||
}
|
||
node = found;
|
||
}
|
||
if (!node) return null;
|
||
}
|
||
const range = document.createRange();
|
||
if (node.nodeType === Node.TEXT_NODE) range.setStart(node, Math.min(offset, node.length));
|
||
else range.setStart(node, Math.min(offset, node.childNodes.length));
|
||
range.collapse(true);
|
||
return range;
|
||
}
|
||
function visibleRange() {
|
||
const a = axis();
|
||
const x = Math.max(1, Math.min(innerWidth - 1, a.vertical && a.reverse ? innerWidth - 20 : 20));
|
||
const y = Math.max(1, Math.min(innerHeight - 1, 20));
|
||
let range = document.caretRangeFromPoint ? document.caretRangeFromPoint(x, y) : null;
|
||
if (range && range.startContainer.nodeType === Node.TEXT_NODE) return range;
|
||
const element = document.elementFromPoint(x, y) || document.body || document.documentElement;
|
||
const walker = document.createTreeWalker(element, NodeFilter.SHOW_TEXT);
|
||
let node, inspected = 0;
|
||
while ((node = walker.nextNode()) && ++inspected < 1000) {
|
||
if (!node.textContent.trim() || !visible(node.parentElement)) continue;
|
||
range = document.createRange(); range.setStart(node, 0); range.collapse(true); return range;
|
||
}
|
||
range = document.createRange(); range.selectNodeContents(element); range.collapse(true); return range;
|
||
}
|
||
function locate() {
|
||
// A font can change layout before its loadingdone event, and a location
|
||
// poll can run before the image's animation-frame restoration. Retain
|
||
// the pre-layout anchor until that restoration has used it.
|
||
if (layoutAnchor && layoutMoved(layoutAnchor)) resourcesSettled();
|
||
// Reflow can put a different character at the viewport sampling point.
|
||
// Keep the restored logical character until the reader actually scrolls.
|
||
const keep = restoredRange && document.documentElement.contains(restoredRange.range.startContainer) &&
|
||
Math.abs(scrollX - restoredRange.x) < 1 && Math.abs(scrollY - restoredRange.y) < 1;
|
||
if (!keep) restoredRange = null;
|
||
const range = keep ? restoredRange.range : visibleRange();
|
||
const node = range.startContainer;
|
||
const element = node.nodeType === Node.ELEMENT_NODE ? node : node.parentElement;
|
||
const rect = range.getBoundingClientRect();
|
||
const result = { url: location.href, cfi: cfiFor(node, range.startOffset), fragment: element && element.id || "",
|
||
progression: progression(), textQuote: node.nodeType === Node.TEXT_NODE ? node.textContent.slice(range.startOffset, range.startOffset + 160) : text(element, 160),
|
||
offsetX: rect.left / Math.max(1, innerWidth), offsetY: rect.top / Math.max(1, innerHeight), writingMode: axis().writingMode,
|
||
currentOutline: currentNavigation(range), navigationRevision };
|
||
if (!resourceRestoreFrame) layoutAnchor = { range: range.cloneRange(), saved: result,
|
||
x:scrollX, y:scrollY, documentX:rect.left + scrollX, documentY:rect.top + scrollY,
|
||
width:innerWidth, height:innerHeight };
|
||
return result;
|
||
}
|
||
function layoutMoved(anchor) {
|
||
if (!anchor.range.startContainer.isConnected || anchor.width !== innerWidth || anchor.height !== innerHeight) return false;
|
||
const rect = anchor.range.getBoundingClientRect();
|
||
return Math.abs(rect.left + scrollX - anchor.documentX) > 1 || Math.abs(rect.top + scrollY - anchor.documentY) > 1;
|
||
}
|
||
function cancelResourceRestore() {
|
||
if (resourceRestoreFrame) cancelAnimationFrame(resourceRestoreFrame);
|
||
resourceRestoreFrame = 0;
|
||
layoutAnchor = null;
|
||
}
|
||
function resourcesSettled() {
|
||
if (resourceRestoreFrame || !layoutAnchor || options.fixed) return;
|
||
const anchor = layoutAnchor;
|
||
resourceRestoreFrame = requestAnimationFrame(() => {
|
||
resourceRestoreFrame = 0;
|
||
// Retain the character and its viewport fraction across a decoded
|
||
// image or font swap. Never insert helper nodes into the source DOM.
|
||
// Clear the old snapshot before locate(), otherwise it would see
|
||
// the same completed layout change and schedule another frame.
|
||
const current = layoutAnchor === anchor;
|
||
if (current) layoutAnchor = null;
|
||
if (current && anchor.range.startContainer.isConnected)
|
||
positionRange(anchor.range, anchor.saved);
|
||
userScrollPending = false;
|
||
locate();
|
||
});
|
||
}
|
||
document.addEventListener("load", event => {
|
||
if (event.isTrusted && event.target instanceof HTMLImageElement) resourcesSettled();
|
||
}, true);
|
||
document.addEventListener("error", event => {
|
||
if (event.isTrusted && event.target instanceof HTMLImageElement) resourcesSettled();
|
||
}, true);
|
||
if (document.fonts) {
|
||
document.fonts.addEventListener("loadingdone", resourcesSettled);
|
||
document.fonts.addEventListener("loadingerror", resourcesSettled);
|
||
}
|
||
for (const type of ["wheel", "touchstart", "touchmove", "pointerdown", "pointermove", "keydown"])
|
||
document.addEventListener(type, event => {
|
||
if (!event.isTrusted || (type === "pointermove" && !event.buttons)) return;
|
||
cancelResourceRestore();
|
||
// Clicking without scrolling must not leave a 400 ms gap without
|
||
// any anchor. A following input scroll still takes precedence.
|
||
if (document.body) locate();
|
||
userScrollPending = true;
|
||
// Input intent applies to this frame, not to an unrelated native
|
||
// anchor adjustment long after a click that did not scroll.
|
||
if (userScrollFrame) cancelAnimationFrame(userScrollFrame);
|
||
userScrollFrame = requestAnimationFrame(() => { userScrollFrame = 0; userScrollPending = false; });
|
||
}, {capture:true, passive:true});
|
||
document.addEventListener("scroll", () => {
|
||
if (layoutAnchor && Math.abs(scrollX - layoutAnchor.x) < 1 && Math.abs(scrollY - layoutAnchor.y) < 1) return;
|
||
if (!userScrollPending && layoutAnchor && layoutMoved(layoutAnchor)) {
|
||
// Native overflow-anchor can move the scroll offset as resources
|
||
// reflow. This is not a new reader navigation.
|
||
resourcesSettled();
|
||
return;
|
||
}
|
||
userScrollPending = false;
|
||
cancelResourceRestore();
|
||
restoredRange = null;
|
||
locate();
|
||
}, {passive:true});
|
||
window.addEventListener("hashchange", () => { cancelResourceRestore(); locate(); });
|
||
function configureNavigation(args) {
|
||
navigationTargets = []; navigationRevision = "";
|
||
if (!args || typeof args.revision !== "string" || !/^[0-9]{1,19}$/.test(args.revision) ||
|
||
!Array.isArray(args.targets) || args.targets.length > 20000) return false;
|
||
const targets = [];
|
||
for (const item of args.targets) {
|
||
if (!item || !Number.isInteger(item.row) || item.row < 0 || item.row >= 20000) return false;
|
||
let element;
|
||
if (Number.isInteger(item.heading) && item.heading >= 0 && item.heading < headings.length)
|
||
element = headings[item.heading].element;
|
||
else if (typeof item.fragment === "string" && item.fragment.length <= 2048)
|
||
element = item.fragment ? document.getElementById(item.fragment) : document.body || document.documentElement;
|
||
if (!visible(element)) continue;
|
||
const range = document.createRange(); range.selectNodeContents(element); range.collapse(true);
|
||
targets.push({ row:item.row, element, range });
|
||
}
|
||
targets.sort((a, b) => a.range.compareBoundaryPoints(Range.START_TO_START, b.range) || a.row - b.row);
|
||
navigationTargets = targets; navigationRevision = args.revision;
|
||
return true;
|
||
}
|
||
function currentNavigation(position) {
|
||
// DOM order is stable across zoom/reflow. Avoid measuring every target's
|
||
// layout at each 400 ms location poll, even for a 20,000-item EPUB nav.
|
||
let low = 0, high = navigationTargets.length;
|
||
while (low < high) {
|
||
const mid = (low + high) >>> 1;
|
||
if (navigationTargets[mid].range.compareBoundaryPoints(Range.START_TO_START, position) <= 0) low = mid + 1;
|
||
else high = mid;
|
||
}
|
||
for (let i = low - 1; i >= 0; --i)
|
||
if (visible(navigationTargets[i].element)) return navigationTargets[i].row;
|
||
return -1;
|
||
}
|
||
function positionRange(range, saved) {
|
||
const node = range.startContainer;
|
||
const element = node.nodeType === Node.ELEMENT_NODE ? node : node.parentElement;
|
||
if (!element || !visible(element)) return false;
|
||
element.scrollIntoView({ block: "start", inline: "start", behavior: "instant" });
|
||
const rect = range.getBoundingClientRect();
|
||
const a = axis();
|
||
const offset = a.vertical ? Number(saved.offsetX) : Number(saved.offsetY);
|
||
const fraction = Number.isFinite(offset) && Math.abs(offset) <= 2 ? offset : 0;
|
||
if (a.vertical) scrollBy({ left: rect.left - fraction * innerWidth, behavior: "instant" });
|
||
else scrollBy({ top: rect.top - fraction * innerHeight, behavior: "instant" });
|
||
restoredRange = { range: range.cloneRange(), x: scrollX, y: scrollY };
|
||
return true;
|
||
}
|
||
function restore(saved) {
|
||
if (!saved || typeof saved !== "object") return { restored: false, approximate: true };
|
||
let range = resolveCfi(saved.cfi);
|
||
if (range && positionRange(range, saved)) return { restored: true, approximate: false };
|
||
const fragment = typeof saved.fragment === "string" ? saved.fragment.slice(0, 1024) : "";
|
||
const element = fragment ? document.getElementById(fragment) : null;
|
||
if (element && visible(element)) {
|
||
restoredRange = null;
|
||
element.scrollIntoView({ block: "start", inline: "start", behavior: "instant" });
|
||
// A failed character-level CFI resolved only to its containing ID.
|
||
return { restored: true, approximate: Boolean(saved.cfi) };
|
||
}
|
||
const quote = typeof saved.textQuote === "string" ? saved.textQuote.slice(0, 160) : "";
|
||
if (quote) {
|
||
const walker = document.createTreeWalker(document.body || document.documentElement, NodeFilter.SHOW_TEXT);
|
||
let node, inspected = 0;
|
||
while ((node = walker.nextNode()) && ++inspected < 100000) {
|
||
const offset = node.textContent.indexOf(quote);
|
||
if (offset >= 0 && visible(node.parentElement)) {
|
||
range = document.createRange(); range.setStart(node, offset); range.collapse(true);
|
||
if (positionRange(range, saved)) return { restored: true, approximate: true };
|
||
}
|
||
}
|
||
}
|
||
setProgression(saved.progression);
|
||
return { restored: true, approximate: true };
|
||
}
|
||
function heading(direction) {
|
||
if (!headings.length) headingIndex();
|
||
const a = axis();
|
||
const candidates = direction > 0 ? headings : headings.slice().reverse();
|
||
const seen = new Set();
|
||
for (const h of candidates) {
|
||
const rect = h.element.getBoundingClientRect();
|
||
const distance = a.vertical ? (a.reverse ? innerWidth - rect.right : rect.left) : rect.top;
|
||
const position = Math.round(distance);
|
||
if (seen.has(position)) continue;
|
||
seen.add(position);
|
||
if ((direction > 0 && distance > 3) || (direction < 0 && distance < -3)) {
|
||
const x = scrollX, y = scrollY;
|
||
h.element.scrollIntoView({ block: "start", inline: "start", behavior: "instant" });
|
||
// Several final headings can clamp to the same destination.
|
||
// Check the current layout's actual result, so a repeated
|
||
// destination cannot masquerade as movement or block a boundary.
|
||
const after = h.element.getBoundingClientRect();
|
||
if (Math.abs(scrollX - x) < 1 && Math.abs(scrollY - y) < 1 &&
|
||
Math.abs(after.left - rect.left) < 1 && Math.abs(after.top - rect.top) < 1) continue;
|
||
return { moved: true, title: h.title };
|
||
}
|
||
}
|
||
return { moved: false, boundary: direction, empty: !headings.length };
|
||
}
|
||
function applyOptions(next) {
|
||
options = Object.assign({}, options, next || {});
|
||
if (!options.fixed && options.publisherStyle === false) {
|
||
const size = Number(options.fontSize), height = Number(options.lineHeight);
|
||
if (!originalTypography) {
|
||
const body = document.body || document.documentElement;
|
||
const base = parseFloat(getComputedStyle(body).fontSize) || 16;
|
||
const nodes = [document.documentElement, body];
|
||
// Inline priorities override authored fixed-pixel declarations.
|
||
// Relative heading/ruby sizes survive; DOM nodes and CFI paths do not change.
|
||
for (const node of body.querySelectorAll("*")) {
|
||
if (node.namespaceURI !== "http://www.w3.org/1999/xhtml") continue;
|
||
if (Array.from(node.childNodes).some(child => child.nodeType === Node.TEXT_NODE && child.textContent.trim())) nodes.push(node);
|
||
}
|
||
originalTypography = Array.from(new Set(nodes)).map(node => ({ node,
|
||
hadStyle: node.hasAttribute("style"),
|
||
font: node.style.getPropertyValue("font-size"), fontPriority: node.style.getPropertyPriority("font-size"),
|
||
line: node.style.getPropertyValue("line-height"), linePriority: node.style.getPropertyPriority("line-height"),
|
||
ratio: node === document.documentElement || node === body ? 1 : (parseFloat(getComputedStyle(node).fontSize) || base) / base }));
|
||
}
|
||
for (const entry of originalTypography) {
|
||
if (size >= 12 && size <= 40) entry.node.style.setProperty("font-size", size * entry.ratio + "px", "important");
|
||
if (height >= 1 && height <= 2.5) entry.node.style.setProperty("line-height", String(height), "important");
|
||
}
|
||
} else if (originalTypography) {
|
||
for (const entry of originalTypography) {
|
||
if (entry.font) entry.node.style.setProperty("font-size", entry.font, entry.fontPriority);
|
||
else entry.node.style.removeProperty("font-size");
|
||
if (entry.line) entry.node.style.setProperty("line-height", entry.line, entry.linePriority);
|
||
else entry.node.style.removeProperty("line-height");
|
||
if (!entry.hadStyle && !entry.node.getAttribute("style")) entry.node.removeAttribute("style");
|
||
}
|
||
originalTypography = null;
|
||
}
|
||
return { fixed: !!options.fixed, fixedViewport: viewport() };
|
||
}
|
||
function restoreLinkOutline() {
|
||
if (!focusedLink || !linkOutline) return;
|
||
for (const entry of linkOutline.properties) {
|
||
if (entry.value) focusedLink.style.setProperty(entry.name, entry.value, entry.priority);
|
||
else focusedLink.style.removeProperty(entry.name);
|
||
}
|
||
if (!linkOutline.hadStyle && !focusedLink.getAttribute("style")) focusedLink.removeAttribute("style");
|
||
linkOutline = null;
|
||
}
|
||
function clearLinkSelection() {
|
||
restoreLinkOutline();
|
||
focusedLink = null;
|
||
// selectedLink also supports a natively focused anchor. Clear both
|
||
// routes so Enter cannot follow a link after selection is cancelled.
|
||
const active = document.activeElement;
|
||
if (active && active.localName === "a") active.blur();
|
||
return { cleared: true };
|
||
}
|
||
function focusLink(direction) {
|
||
const links = Array.from(document.querySelectorAll("a[href]")).filter(visible).slice(0, 20000);
|
||
if (!links.length) return { empty: true };
|
||
const current = links.indexOf(focusedLink || document.activeElement);
|
||
const index = current < 0 ? (direction > 0 ? 0 : links.length - 1) : (current + direction + links.length) % links.length;
|
||
restoreLinkOutline();
|
||
focusedLink = links[index];
|
||
linkOutline = { hadStyle: focusedLink.hasAttribute("style"),
|
||
properties: ["outline-color", "outline-style", "outline-width", "outline-offset"].map(name => ({
|
||
name, value: focusedLink.style.getPropertyValue(name), priority: focusedLink.style.getPropertyPriority(name)
|
||
})) };
|
||
focusedLink.style.outline = "2px solid #008577";
|
||
focusedLink.style.outlineOffset = "3px";
|
||
focusedLink.focus({ preventScroll: false });
|
||
return { focused: true, title: text(focusedLink), index, count: links.length };
|
||
}
|
||
function selectedLink() {
|
||
const element = focusedLink && focusedLink.isConnected ? focusedLink : document.activeElement;
|
||
if (!element || element.localName !== "a" || !element.hasAttribute("href")) return { empty: true };
|
||
try {
|
||
const url = new URL(element.getAttribute("href"), document.baseURI);
|
||
if (!["doc:", "http:", "https:"].includes(url.protocol) || url.username || url.password) return { blocked: true };
|
||
if (url.protocol === "doc:" && url.host !== location.host) return { blocked: true };
|
||
return { url: url.href.slice(0, 8192), title: text(element) };
|
||
} catch (_) { return { blocked: true }; }
|
||
}
|
||
function executeCommand(id, args) {
|
||
args = args && typeof args === "object" ? args : {};
|
||
const a = axis();
|
||
const step = Math.max(1, Math.min(100, Number(args.count) || 1));
|
||
switch (id) {
|
||
case "resource.issues": {
|
||
const result = resourceIssues;
|
||
resourceIssues = Object.create(null);
|
||
return result;
|
||
}
|
||
case "index": return index();
|
||
case "location": return locate();
|
||
case "navigation.configure": return configureNavigation(args);
|
||
case "location.restore": return restore(args);
|
||
case "layout": return applyOptions(args);
|
||
case "link.next": return focusLink(1);
|
||
case "link.previous": return focusLink(-1);
|
||
case "link.clear": return clearLinkSelection();
|
||
case "link.activate": return selectedLink();
|
||
case "scroll.down": scrollBy({ top: 48 * step, behavior: "instant" }); break;
|
||
case "scroll.up": scrollBy({ top: -48 * step, behavior: "instant" }); break;
|
||
case "scroll.left": scrollBy({ left: -48 * step, behavior: "instant" }); break;
|
||
case "scroll.right": scrollBy({ left: 48 * step, behavior: "instant" }); break;
|
||
case "scroll.half_down": case "scroll.half_up": case "scroll.page_down": case "scroll.page_up": {
|
||
const forward = id.endsWith("down") ? 1 : -1;
|
||
const size = id.includes("half") ? 0.5 : 0.9;
|
||
scrollBy(a.vertical ? { left: innerWidth * size * forward * (a.reverse ? -1 : 1), behavior: "instant" }
|
||
: { top: innerHeight * size * forward, behavior: "instant" }); break;
|
||
}
|
||
case "nav.document_start": setProgression(0); break;
|
||
case "nav.document_end": setProgression(1); break;
|
||
case "nav.heading_next": return heading(1);
|
||
case "nav.heading_previous": return heading(-1);
|
||
case "heading.first": if (!headings.length) headingIndex(); if (headings.length) headings[0].element.scrollIntoView({block:"start",inline:"start"}); return {moved:!!headings.length};
|
||
case "heading.last": if (!headings.length) headingIndex(); if (headings.length) headings[headings.length-1].element.scrollIntoView({block:"start",inline:"start"}); return {moved:!!headings.length};
|
||
case "heading.index": {
|
||
const index = Number(args.index);
|
||
if (Number.isInteger(index) && index >= 0 && index < headings.length) headings[index].element.scrollIntoView({ block: "start", inline: "start", behavior: "instant" });
|
||
break;
|
||
}
|
||
default: return { handled: false };
|
||
}
|
||
return { handled: true };
|
||
}
|
||
function command(id, args) {
|
||
const passive = ["location", "index", "navigation.configure", "resource.issues"].includes(id);
|
||
if (!passive) { cancelResourceRestore(); userScrollPending = false; }
|
||
try { return executeCommand(id, args); }
|
||
finally { if (!passive && document.body) locate(); }
|
||
}
|
||
function block(event) { event.preventDefault(); event.stopImmediatePropagation(); }
|
||
document.addEventListener("submit", block, true);
|
||
document.addEventListener("reset", block, true);
|
||
document.addEventListener("beforeinput", block, true);
|
||
document.addEventListener("drop", block, true);
|
||
document.addEventListener("click", event => {
|
||
if (event.target.closest && event.target.closest("button,input,select,textarea,[contenteditable]")) block(event);
|
||
}, true);
|
||
document.addEventListener("keydown", event => {
|
||
if (event.target.closest && event.target.closest("button,input,select,textarea,[contenteditable]") && !(event.ctrlKey && /^(a|c)$/i.test(event.key))) block(event);
|
||
}, true);
|
||
document.addEventListener("play", event => { if (event.target.pause) event.target.pause(); }, true);
|
||
globalThis.__docviewReader = Object.freeze({ command, index, location: locate, restore });
|
||
})();
|