frond-js 0.4.0

package/dist/default-DRLIJX73.js

@@ -0,0 +1,1183 @@
+import { classifyReference, resolveArchivePath, directoryOf } from './chunk-U4264IQH.js';
+import { StateError, throwIfAborted, FormatError, onAbort, SecurityError, createAbortError } from './chunk-B2L2YVXD.js';
+
+// src/render/default/cfi-locate.ts
+var ELEMENT_NODE = 1;
+var TEXT_NODE = 3;
+var CDATA_NODE = 4;
+function isElementNode(node) {
+  return node.nodeType === ELEMENT_NODE;
+}
+function isCharacterData(node) {
+  return node.nodeType === TEXT_NODE || node.nodeType === CDATA_NODE;
+}
+function indexChildNodes(node) {
+  const slots = [];
+  for (const child of Array.from(node.childNodes)) {
+    if (!isElementNode(child) && !isCharacterData(child)) continue;
+    if (isCharacterData(child)) {
+      const last = slots[slots.length - 1];
+      if (last !== void 0 && last.kind === "chunk") last.nodes.push(child);
+      else slots.push({ kind: "chunk", nodes: [child] });
+      continue;
+    }
+    if (slots[slots.length - 1]?.kind === "element") slots.push({ kind: "gap" });
+    slots.push({ kind: "element", node: child });
+  }
+  const head = slots[0];
+  if (head !== void 0 && head.kind === "element") {
+    slots.unshift({ kind: "edge", node: head.node });
+  }
+  const tail = slots[slots.length - 1];
+  if (tail !== void 0 && tail.kind === "element") {
+    slots.push({ kind: "edge", node: tail.node });
+  }
+  slots.unshift({ kind: "before" });
+  slots.push({ kind: "after" });
+  return slots;
+}
+function locateInChunk(chunk, offset) {
+  let remaining = offset;
+  for (const node of chunk) {
+    const length = node.nodeValue?.length ?? 0;
+    if (remaining <= length) return { node, offset: remaining };
+    remaining -= length;
+  }
+  return void 0;
+}
+function closestElement(node) {
+  let current = node;
+  while (current !== null) {
+    if (isElementNode(current)) return current;
+    current = current.parentNode;
+  }
+  return void 0;
+}
+function foldWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function checkIdAssertion(node, expected, stepIndex, tally) {
+  tally.checked += 1;
+  const actual = isElementNode(node) ? node.id : null;
+  if (actual !== expected) {
+    tally.failures.push({ step: stepIndex, kind: "id", expected, actual });
+  }
+}
+function locateCfi(root, cfi) {
+  const doc = root === void 0 || root === null ? void 0 : root.ownerDocument;
+  if (doc === void 0 || doc === null) {
+    throw new StateError("locateCfi() \u9700\u8981\u4E00\u4E2A\u542B ownerDocument \u7684 root\uFF08\u89C1 Element \u5951\u7EA6\uFF09");
+  }
+  const point = cfi.kind === "range" ? cfi.start : cfi;
+  const path = point.paths[point.paths.length - 1];
+  if (path === void 0) return void 0;
+  const steps = path.steps;
+  if (steps.length === 0) return void 0;
+  const tally = { checked: 0, failures: [] };
+  const lastStep = steps[steps.length - 1];
+  if (lastStep !== void 0 && lastStep.id !== void 0) {
+    const byId = doc.getElementById(lastStep.id);
+    if (byId !== null) {
+      tally.checked += 1;
+      return {
+        node: byId,
+        element: byId,
+        offset: 0,
+        viaIdAssertion: true,
+        assertions: { checked: tally.checked, matched: 1, failures: [] }
+      };
+    }
+  }
+  let current = root;
+  let offset = 0;
+  steps: for (const [stepIndex, step] of steps.entries()) {
+    const slot = indexChildNodes(current)[step.index];
+    if (slot === void 0) return void 0;
+    switch (slot.kind) {
+      case "before":
+      case "after":
+      case "gap":
+        if (step.id !== void 0) checkIdAssertion(current, step.id, stepIndex, tally);
+        offset = 0;
+        break steps;
+      case "edge":
+        if (step.id !== void 0) checkIdAssertion(slot.node, step.id, stepIndex, tally);
+        current = slot.node;
+        offset = 0;
+        break steps;
+      case "chunk": {
+        if (stepIndex !== steps.length - 1) return void 0;
+        const located = locateInChunk(slot.nodes, point.offset ?? 0);
+        if (located === void 0) return void 0;
+        if (step.id !== void 0) checkIdAssertion(located.node, step.id, stepIndex, tally);
+        current = located.node;
+        offset = located.offset;
+        break steps;
+      }
+      case "element":
+        if (step.id !== void 0) checkIdAssertion(slot.node, step.id, stepIndex, tally);
+        current = slot.node;
+        offset = 0;
+    }
+  }
+  const element = closestElement(current);
+  if (element === void 0) return void 0;
+  const value = isCharacterData(current) ? current.nodeValue ?? "" : "";
+  for (const [kind, expected] of [
+    ["text", point.text],
+    ["textAfter", point.textAfter]
+  ]) {
+    if (expected === void 0) continue;
+    tally.checked += 1;
+    const actual = foldWhitespace(kind === "text" ? value.slice(0, offset) : value.slice(offset));
+    const wanted = foldWhitespace(expected);
+    const matched = kind === "text" ? actual.endsWith(wanted) : actual.startsWith(wanted);
+    if (!matched) tally.failures.push({ step: steps.length - 1, kind, expected, actual });
+  }
+  return {
+    node: current,
+    element,
+    offset,
+    viaIdAssertion: false,
+    assertions: {
+      checked: tally.checked,
+      matched: tally.checked - tally.failures.length,
+      failures: tally.failures
+    }
+  };
+}
+
+// src/render/default/sandbox.ts
+var CONTENT_SANDBOX = "allow-same-origin";
+var CONTENT_CSP_DIRECTIVES = [
+  "default-src 'none'",
+  "script-src 'none'",
+  "object-src 'none'",
+  "base-uri 'none'",
+  "form-action 'none'",
+  "connect-src 'none'",
+  "img-src blob: data:",
+  "media-src blob:",
+  "style-src blob: 'unsafe-inline'",
+  "font-src blob: data:"
+];
+var CSP_HTTP_EQUIV = "content-security-policy";
+function decodeAttr(value) {
+  return value.replace(/&quot;/g, '"').replace(/&#39;/g, "'").replace(/&amp;/g, "&");
+}
+function* startTags(html) {
+  let i = 0;
+  for (; ; ) {
+    const lt = html.indexOf("<", i);
+    if (lt < 0) return;
+    if (html.startsWith("<!--", lt)) {
+      const close = html.indexOf("-->", lt + 4);
+      if (close < 0) return;
+      i = close + 3;
+      continue;
+    }
+    const rawName = /^<([a-zA-Z][^\s/>]*)/.exec(html.slice(lt))?.[1];
+    if (rawName === void 0) {
+      i = lt + 1;
+      continue;
+    }
+    const attrs = /* @__PURE__ */ new Map();
+    let j = lt + rawName.length + 1;
+    let closed = false;
+    while (j < html.length) {
+      const char = html[j];
+      if (char === ">") {
+        closed = true;
+        j += 1;
+        break;
+      }
+      if (char === '"' || char === "'") {
+        const close = html.indexOf(char, j + 1);
+        if (close < 0) break;
+        j = close + 1;
+        continue;
+      }
+      const key = /^[a-zA-Z][a-zA-Z0-9-]*/.exec(html.slice(j))?.[0];
+      if (key === void 0) {
+        j += 1;
+        continue;
+      }
+      const name = key.toLowerCase();
+      let k = j + key.length;
+      while (k < html.length && /\s/.test(html.charAt(k))) k += 1;
+      if (html[k] !== "=") {
+        if (!attrs.has(name)) attrs.set(name, "");
+        j = k;
+        continue;
+      }
+      k += 1;
+      while (k < html.length && /\s/.test(html.charAt(k))) k += 1;
+      const quote = html[k];
+      if (quote === '"' || quote === "'") {
+        const close = html.indexOf(quote, k + 1);
+        if (close < 0) break;
+        if (!attrs.has(name)) attrs.set(name, decodeAttr(html.slice(k + 1, close)));
+        j = close + 1;
+      } else {
+        const raw = /^[^\s>]*/.exec(html.slice(k))?.[0] ?? "";
+        if (!attrs.has(name)) attrs.set(name, decodeAttr(raw));
+        j = k + raw.length;
+      }
+    }
+    if (!closed) return;
+    yield { name: rawName.toLowerCase(), start: lt, end: j, attrs };
+    i = j;
+  }
+}
+function cspMetaTags(html) {
+  const found = [];
+  for (const tag of startTags(html)) {
+    if (tag.name === "meta" && (tag.attrs.get("http-equiv") ?? "").toLowerCase() === CSP_HTTP_EQUIV) {
+      found.push(tag);
+    }
+    if (tag.name === "body") break;
+  }
+  return found;
+}
+function headTag(html) {
+  for (const tag of startTags(html)) {
+    if (tag.name === "head") return tag;
+    if (tag.name === "body") return void 0;
+  }
+  return void 0;
+}
+var WELL_FORMED_DIRECTIVE = /^[a-zA-Z0-9-]+(\s[\s\S]*)?$/;
+function mergeCsp(bookPolicy) {
+  if (bookPolicy.trim() === "") return buildContentCsp();
+  const ours = new Set(CONTENT_CSP_DIRECTIVES.map((d) => d.trim().split(/\s+/)[0]));
+  const kept = bookPolicy.split(";").map((d) => d.trim()).filter((d) => {
+    if (d === "" || !WELL_FORMED_DIRECTIVE.test(d)) return false;
+    const space = d.search(/\s/);
+    const name = space === -1 ? d : d.slice(0, space);
+    return !ours.has(name.toLowerCase());
+  });
+  return [buildContentCsp(), ...kept].join("; ");
+}
+function metaTagFor(policy) {
+  const content = policy.replace(/&/g, "&amp;").replace(/"/g, "&quot;");
+  return `<meta http-equiv="Content-Security-Policy" content="${content}">`;
+}
+function buildContentCsp(directives = CONTENT_CSP_DIRECTIVES) {
+  if (directives.length === 0) {
+    throw new SecurityError("\u5185\u5BB9 CSP \u7684\u6307\u4EE4\u5217\u8868\u4E3A\u7A7A \u2014\u2014 \u7A7A CSP \u7B49\u4E8E\u6CA1\u6709 CSP");
+  }
+  for (const directive of directives) {
+    if (directive.trim() === "") {
+      throw new SecurityError("\u5185\u5BB9 CSP \u542B\u7A7A\u6307\u4EE4 \u2014\u2014 \u62FC\u63A5\u7ED3\u679C\u4F1A\u51FA\u73B0 `;;`\uFF0C\u89E3\u6790\u884C\u4E3A\u4E0D\u53EF\u4F9D\u8D56");
+    }
+  }
+  const scriptSrc = directives.find((directive) => directive.startsWith("script-src "));
+  if (scriptSrc === void 0) {
+    throw new SecurityError(
+      "\u5185\u5BB9 CSP \u7F3A\u5C11 script-src \u2014\u2014 \u300C\u6CA1\u5199\u300D\u4E0D\u7B49\u4E8E\u300C\u7981\u6B62\u300D\uFF0CH9 \u8981\u6C42\u663E\u5F0F 'none'"
+    );
+  }
+  if (scriptSrc.trim() !== "script-src 'none'") {
+    throw new SecurityError(
+      `\u5185\u5BB9 CSP \u7684 script-src \u5FC5\u987B\u662F 'none'\uFF0C\u5B9E\u9645\u4E3A ${JSON.stringify(scriptSrc.slice("script-src ".length))} \u2014\u2014 \u672C\u9879\u76EE\u5185\u5BB9\u4E0E\u5BBF\u4E3B\u540C\u6E90\uFF0C\u4EFB\u4F55\u653E\u884C\u90FD\u7B49\u4E8E\u653E\u5F03\u811A\u672C\u9632\u7EBF`
+    );
+  }
+  return directives.join("; ");
+}
+function allowsScripts(sandboxValue) {
+  if (sandboxValue === null) return false;
+  return sandboxValue.trim().split(/\s+/).filter((token) => token !== "").includes("allow-scripts");
+}
+function withContentCsp(html) {
+  const existing = cspMetaTags(html);
+  let stripped = "";
+  let cursor = 0;
+  for (const meta of existing) {
+    stripped += html.slice(cursor, meta.start);
+    cursor = meta.end;
+  }
+  stripped += html.slice(cursor);
+  const head = headTag(stripped);
+  if (head === void 0) {
+    throw new SecurityError(
+      '\u5185\u5BB9 HTML \u4E2D\u627E\u4E0D\u5230\u53EF\u7528\u7684 <head> \u2014\u2014 \u62D2\u7EDD\u9759\u9ED8\u8865\u4E00\u4E2A\uFF1AEPUB \u7AE0\u8282\u662F XHTML\uFF0C\u7F3A <head> \u8BF4\u660E\u4E0A\u6E38\u89E3\u6790\u94FE\u51FA\u4E86\u95EE\u9898\uFF0C\u8865 head \u4F1A\u8BA9 CSP \u56E0\u4F4D\u7F6E\u4E0D\u5BF9\u800C\u5931\u6548\uFF0C\u6BD4\u76F4\u63A5\u62A5\u9519\u5371\u9669\u5F97\u591A\u3002\u26A0\uFE0F \u53E6\u4E00\u79CD\u89E6\u53D1\uFF08FI-X19 \u2462\uFF09\uFF1A`<head data-a="x>` \u8FD9\u7C7B\u672A\u95ED\u5408\u5F15\u53F7\u4F1A\u628A\u5176\u540E\u6574\u4EFD\u6587\u6863\u5403\u6210\u5C5E\u6027\u503C\uFF0C\u6B64\u65F6\u6CA1\u6709\u4EFB\u4F55\u4F4D\u7F6E\u80FD\u8BA9 meta \u6210\u4E3A\u5143\u7D20 \u2014\u2014 \u6240\u4EE5\u8FD9\u91CC**\u629B\u9519**\u800C\u4E0D\u662F\u300C\u63D2\u4E86\u518D\u8BF4\u300D\u3002'
+    );
+  }
+  const bookPolicy = existing.map((meta) => meta.attrs.get("content") ?? "").join("; ");
+  return stripped.slice(0, head.end) + metaTagFor(mergeCsp(bookPolicy)) + stripped.slice(head.end);
+}
+function withDocumentAttributes(html, attributes) {
+  const language = attributes?.language?.trim() ?? "";
+  const requested = attributes?.direction;
+  const direction = requested === "ltr" || requested === "rtl" ? requested : void 0;
+  if (language === "" && direction === void 0) return html;
+  const OPEN_TAG = /<html\b([^>]*)>/i;
+  const match = OPEN_TAG.exec(html);
+  if (match === null) {
+    throw new FormatError(
+      "\u5185\u5BB9 HTML \u4E2D\u627E\u4E0D\u5230 <html> \u5F00\u6807\u7B7E \u2014\u2014 \u62D2\u7EDD\u9759\u9ED8\u8DF3\u8FC7\u6587\u6863\u6807\u6CE8\uFF1A\u8DF3\u8FC7\u4F1A\u8BA9\u300Ca11y \u5DF2\u6807\u6CE8\u300D\u53D8\u6210\u4E00\u53E5\u6CA1\u6709\u8BC1\u636E\u7684\u8BDD\uFF08PROMPT \xA71\uFF1A\u663E\u5F0F\u5931\u8D25 > \u9759\u9ED8\u964D\u7EA7\uFF09"
+    );
+  }
+  const openTagAttributes = match[1] ?? "";
+  const insertions = [];
+  if (language !== "" && !/(?:^|\s)lang\s*=/i.test(openTagAttributes)) {
+    insertions.push(` lang="${language.replace(/&/g, "&amp;").replace(/"/g, "&quot;")}"`);
+  }
+  if (direction !== void 0 && !/(?:^|\s)dir\s*=/i.test(openTagAttributes)) {
+    insertions.push(` dir="${direction}"`);
+  }
+  if (insertions.length === 0) return html;
+  const insertion = insertions.join("");
+  return html.replace(OPEN_TAG, (openTag) => {
+    return `${openTag.slice(0, -1)}${insertion}>`;
+  });
+}
+function applyContentSandbox(frame, html, content) {
+  const securedHtml = withDocumentAttributes(withContentCsp(html), content);
+  frame.setAttribute("sandbox", CONTENT_SANDBOX);
+  if (allowsScripts(frame.getAttribute("sandbox"))) {
+    throw new SecurityError(
+      "\u6C99\u7BB1\u5199\u5165\u70B9\u81EA\u68C0\u5931\u8D25\uFF1A\u5199\u5165\u540E sandbox \u5C5E\u6027\u5141\u8BB8\u811A\u672C\u6267\u884C\u3002\u8FD9\u662F ADR-0008 \u7684 A4/A7 \u5931\u6548\u6A21\u5F0F\uFF0C\u6E32\u67D3\u5FC5\u987B\u6574\u4F53\u5931\u8D25\u800C\u4E0D\u662F\u7EE7\u7EED"
+    );
+  }
+  const url = URL.createObjectURL(new Blob([securedHtml], { type: "text/html" }));
+  frame.src = url;
+  return url;
+}
+
+// src/render/default/frame.ts
+var DEFAULT_IMAGE_TIMEOUT_MS = 3e3;
+var WRAPPER_MARKER = "data-frond-frame-buffer";
+function createFrameBuffer(host) {
+  const { element, ownerDocument } = host;
+  if (element === void 0 || ownerDocument === void 0) {
+    throw new StateError(
+      "createFrameBuffer() \u9700\u8981\u4E00\u4E2A\u542B element \u4E0E ownerDocument \u7684\u5BBF\u4E3B\uFF08\u89C1 RenderHost \u5951\u7EA6\uFF09"
+    );
+  }
+  const wrapper = ownerDocument.createElement("div");
+  wrapper.setAttribute(WRAPPER_MARKER, "");
+  wrapper.style.position = "relative";
+  wrapper.style.width = "100%";
+  wrapper.style.height = "100%";
+  const first = createFrame(ownerDocument, wrapper);
+  const second = createFrame(ownerDocument, wrapper);
+  let visibleIsFirst = true;
+  let disposed = false;
+  const pageUrls = /* @__PURE__ */ new Map();
+  function applyVisibility() {
+    first.style.visibility = visibleIsFirst ? "visible" : "hidden";
+    second.style.visibility = visibleIsFirst ? "hidden" : "visible";
+  }
+  function assertAlive(operation) {
+    if (disposed) {
+      throw new StateError(
+        `\u5E27\u7F13\u51B2\u533A\u5DF2\u91CA\u653E\uFF0C\u4E0D\u80FD\u518D\u8C03\u7528 ${operation}() \u2014\u2014 \u91CA\u653E\u540E\u9759\u9ED8\u64CD\u4F5C\u5DF2\u79FB\u9664\u7684\u5E27\u53EA\u4F1A\u5236\u9020\u96BE\u67E5\u7684\u5E7D\u7075\u6E32\u67D3`
+      );
+    }
+  }
+  function assertOwned(frame, operation) {
+    if (frame !== first && frame !== second) {
+      throw new StateError(
+        `${operation}() \u6536\u5230\u7684\u5E27\u4E0D\u5C5E\u4E8E\u672C\u7F13\u51B2\u533A \u2014\u2014 \u4F20\u522B\u7684\u5E27\u4F1A\u5BFC\u81F4\u300C\u7B49\u4E86\u522B\u4EBA\u7684\u5E27\u3001\u6D4B\u4E86\u81EA\u5DF1\u7684\u5E27\u300D`
+      );
+    }
+  }
+  async function waitForLayoutOn(frame, options, operation) {
+    const { signal, imageTimeoutMs = DEFAULT_IMAGE_TIMEOUT_MS } = options;
+    throwIfAborted(signal);
+    assertAlive(operation);
+    assertOwned(frame, operation);
+    const doc = frame.contentDocument;
+    if (doc === null) {
+      throw new StateError(
+        `${operation}() \u62FF\u4E0D\u5230\u5E27\u7684 contentDocument \u2014\u2014 \u8BE5\u5E27\u5904\u4E8E opaque origin\u3002ADR-0008 \u5B9E\u6D4B\uFF1Asandbox \u672A\u5E26 allow-same-origin \u65F6\u5C31\u662F\u8FD9\u4E2A\u75C7\u72B6\uFF0C\u6B64\u65F6\u5206\u9875\u6D4B\u91CF\u4F1A\u6C38\u8FDC\u4E3A\u7A7A\uFF0C\u5FC5\u987B\u5F53\u573A\u5931\u8D25\u800C\u4E0D\u662F\u9759\u9ED8\u7B49\u5F85`
+      );
+    }
+    await raceWithAbort(doc.fonts.ready, signal);
+    await waitForImages(doc, imageTimeoutMs, signal);
+    return doc;
+  }
+  applyVisibility();
+  element.appendChild(wrapper);
+  return {
+    get visible() {
+      return visibleIsFirst ? first : second;
+    },
+    get hidden() {
+      return visibleIsFirst ? second : first;
+    },
+    swap() {
+      assertAlive("swap");
+      visibleIsFirst = !visibleIsFirst;
+      applyVisibility();
+    },
+    async load(frame, html, options = {}) {
+      const { signal } = options;
+      throwIfAborted(signal);
+      assertAlive("load");
+      assertOwned(frame, "load");
+      const waiter = waitForFrameLoad(frame, signal);
+      const previous = pageUrls.get(frame);
+      let url;
+      try {
+        url = applyContentSandbox(frame, html, options);
+      } catch (error) {
+        waiter.cancel();
+        throw error;
+      }
+      pageUrls.set(frame, url);
+      try {
+        await waiter.promise;
+      } catch (error) {
+        if (previous === void 0) pageUrls.delete(frame);
+        else pageUrls.set(frame, previous);
+        URL.revokeObjectURL(url);
+        throw error;
+      }
+      if (previous !== void 0) URL.revokeObjectURL(previous);
+      return await waitForLayoutOn(frame, options, "load");
+    },
+    async waitForLayout(frame, options = {}) {
+      await waitForLayoutOn(frame, options, "waitForLayout");
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      wrapper.remove();
+      for (const pageUrl of pageUrls.values()) URL.revokeObjectURL(pageUrl);
+      pageUrls.clear();
+    }
+  };
+}
+function createFrame(ownerDocument, wrapper) {
+  const frame = ownerDocument.createElement("iframe");
+  frame.style.position = "absolute";
+  frame.style.top = "0";
+  frame.style.left = "0";
+  frame.style.width = "100%";
+  frame.style.height = "100%";
+  frame.style.border = "0";
+  wrapper.appendChild(frame);
+  return frame;
+}
+function waitForFrameLoad(frame, signal) {
+  let resolvePromise;
+  let rejectPromise;
+  let detachAbort;
+  function cleanup() {
+    frame.removeEventListener("load", onLoad);
+    detachAbort();
+  }
+  function settle(error) {
+    cleanup();
+    if (error === void 0) resolvePromise();
+    else rejectPromise(error);
+  }
+  function onLoad() {
+    settle();
+  }
+  function onAbortSignal() {
+    settle(createAbortError());
+  }
+  const promise = new Promise((resolve, reject) => {
+    resolvePromise = resolve;
+    rejectPromise = reject;
+    frame.addEventListener("load", onLoad);
+    detachAbort = onAbort(signal, onAbortSignal);
+  });
+  return {
+    promise,
+    /**
+     * 放弃等待。**静默结束**（resolve 而非 reject）：调用方此时已因别的错误抛出，
+     * 没有任何人会 `await` 这个 promise —— 若在这里 reject 就变成未处理的 rejection。
+     */
+    cancel() {
+      settle();
+    }
+  };
+}
+function raceWithAbort(task, signal) {
+  if (signal === void 0) return task;
+  let detach;
+  const aborted = new Promise((_resolve, reject) => {
+    detach = onAbort(signal, () => {
+      reject(createAbortError());
+    });
+  });
+  return Promise.race([task, aborted]).finally(() => {
+    detach();
+  });
+}
+function waitForImages(doc, timeoutMs, signal) {
+  const pending = [...doc.images].filter((image) => !image.complete);
+  if (pending.length === 0) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    let remaining = pending.length;
+    const cleanup = [];
+    const settle = (error) => {
+      for (const undo of cleanup) undo();
+      if (error === void 0) resolve();
+      else reject(error);
+    };
+    const onImageSettled = () => {
+      remaining -= 1;
+      if (remaining === 0) settle();
+    };
+    for (const image of pending) {
+      image.addEventListener("load", onImageSettled);
+      image.addEventListener("error", onImageSettled);
+      cleanup.push(() => {
+        image.removeEventListener("load", onImageSettled);
+        image.removeEventListener("error", onImageSettled);
+      });
+    }
+    const timer = setTimeout(settle, timeoutMs);
+    cleanup.push(() => {
+      clearTimeout(timer);
+    });
+    cleanup.push(
+      onAbort(signal, () => {
+        settle(createAbortError());
+      })
+    );
+  });
+}
+
+// src/render/default/paginator.ts
+var MIRRORED_WRITING_MODES = ["vertical-rl", "sideways-rl"];
+var FORWARD_VERTICAL_WRITING_MODES = ["vertical-lr", "sideways-lr"];
+function isMirroredAxis(direction, writingMode) {
+  if (MIRRORED_WRITING_MODES.includes(writingMode)) return true;
+  if (FORWARD_VERTICAL_WRITING_MODES.includes(writingMode)) return false;
+  return direction === "rtl";
+}
+function isVerticalWriting(writingMode) {
+  return MIRRORED_WRITING_MODES.includes(writingMode) || FORWARD_VERTICAL_WRITING_MODES.includes(writingMode);
+}
+function computePageCount(scrollWidth, pageWidth) {
+  return Math.ceil(scrollWidth / pageWidth);
+}
+function pageOf(metrics, rect) {
+  const offset = metrics.mirrored ? metrics.originRight - rect.right : rect.left - metrics.originLeft;
+  const page = Math.floor(offset / metrics.pageWidth);
+  return Math.min(Math.max(page, 0), metrics.pageCount - 1);
+}
+function pageOfElement(element, metrics) {
+  const rect = element.getBoundingClientRect();
+  return pageOf(metrics, { left: rect.left, right: rect.right });
+}
+function createPaginator(doc, options = {}) {
+  const root = doc.documentElement;
+  if (root === null) {
+    throw new StateError(
+      "createPaginator() \u9700\u8981\u4E00\u4E2A\u542B documentElement \u7684\u6587\u6863 \u2014\u2014 \u5206\u9875\u7684\u5168\u90E8\u6837\u5F0F\u4E0E\u51E0\u4F55\u90FD\u6302\u5728\u5185\u5BB9\u6839\u4E0A"
+    );
+  }
+  const view = doc.defaultView;
+  if (view === null) {
+    throw new StateError(
+      "createPaginator() \u62FF\u4E0D\u5230 defaultView \u2014\u2014 \u8BE5\u6587\u6863\u6CA1\u6709\u6D4F\u89C8\u4E0A\u4E0B\u6587\uFF08\u5982 createHTMLDocument() \u7684\u4EA7\u7269\uFF09\uFF0C\u65E2\u8BFB\u4E0D\u5230\u4E66\u5199\u65B9\u5411\u4E5F\u65E0\u6CD5\u5206\u9875"
+    );
+  }
+  const { columnGapPx = 0, minPageSizePx = 1 } = options;
+  const style = root.style;
+  const savedStyles = /* @__PURE__ */ new Map();
+  let mode = options.mode ?? "paginated";
+  let disposed = false;
+  function writeStyle(property, value) {
+    if (!savedStyles.has(property)) savedStyles.set(property, style.getPropertyValue(property));
+    style.setProperty(property, value);
+  }
+  function restoreAll() {
+    for (const [property, previous] of savedStyles) {
+      if (previous === "") style.removeProperty(property);
+      else style.setProperty(property, previous);
+    }
+  }
+  function assertAlive(operation) {
+    if (disposed) {
+      throw new StateError(
+        `\u5206\u9875\u5668\u5DF2\u91CA\u653E\uFF0C\u4E0D\u80FD\u518D\u8C03\u7528 ${operation}() \u2014\u2014 \u91CA\u653E\u65F6\u6587\u6863\u7684\u884C\u5185\u6837\u5F0F\u5DF2\u6062\u590D\uFF0C\u7EE7\u7EED\u65BD\u52A0\u4F1A\u7559\u4E0B\u4E00\u4EFD\u65E0\u4EBA\u8D1F\u8D23\u7684\u6392\u7248`
+      );
+    }
+  }
+  function applyPaginated() {
+    writeStyle("height", "100%");
+    writeStyle("overflow", "hidden");
+    writeStyle("column-gap", `${String(columnGapPx)}px`);
+    writeStyle("column-fill", "auto");
+  }
+  if (mode === "paginated") applyPaginated();
+  return {
+    get mode() {
+      return mode;
+    },
+    get verticalWriting() {
+      return isVerticalWriting(view.getComputedStyle(root).writingMode);
+    },
+    setMode(nextMode, setModeOptions = {}) {
+      assertAlive("setMode");
+      throwIfAborted(setModeOptions.signal);
+      if (nextMode === mode) return;
+      mode = nextMode;
+      if (nextMode === "paginated") applyPaginated();
+      else restoreAll();
+    },
+    measure(measureOptions = {}) {
+      assertAlive("measure");
+      throwIfAborted(measureOptions.signal);
+      if (mode !== "paginated") {
+        throw new StateError(
+          "measure() \u53EA\u5728\u5206\u9875\u6A21\u5F0F\u4E0B\u6709\u610F\u4E49 \u2014\u2014 \u6EDA\u52A8\u6A21\u5F0F\u6CA1\u6709\u300C\u9875\u300D\uFF0C\u8FD4\u56DE\u4EFB\u4F55\u9875\u6570\u90FD\u662F\u7F16\u9020"
+        );
+      }
+      const pageWidth = root.clientWidth;
+      const pageHeight = root.clientHeight;
+      if (pageWidth < minPageSizePx || pageHeight < minPageSizePx) {
+        throw new StateError(
+          `\u5206\u9875\u9700\u8981\u786E\u5B9A\u7684\u5BBF\u4E3B\u5C3A\u5BF8\uFF0C\u5B9E\u6D4B ${String(pageWidth)}\xD7${String(pageHeight)}px\uFF08\u4E0B\u9650 ${String(minPageSizePx)}px\uFF09\u2014\u2014 \u9AD8\u5EA6 auto / 0 \u4F1A\u8BA9\u9875\u6570\u9759\u9ED8\u81A8\u80C0\u6210\u8352\u8C2C\u503C`
+        );
+      }
+      writeStyle("column-width", `${String(pageWidth)}px`);
+      const scrollWidth = root.scrollWidth;
+      const computed = view.getComputedStyle(root);
+      const rect = root.getBoundingClientRect();
+      return {
+        mode,
+        pageCount: computePageCount(scrollWidth, pageWidth),
+        pageWidth,
+        pageHeight,
+        originLeft: rect.left,
+        originRight: rect.right,
+        mirrored: isMirroredAxis(computed.direction, computed.writingMode)
+      };
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      restoreAll();
+    }
+  };
+}
+
+// src/render/default/resources.ts
+function resolveArchiveReference(rawValue, sourcePath) {
+  if (classifyReference(rawValue) !== "archive") return void 0;
+  try {
+    return resolveArchivePath(directoryOf(sourcePath), rawValue.trim());
+  } catch (error) {
+    if (error instanceof FormatError) return void 0;
+    throw error;
+  }
+}
+var CSS_KEY_PREFIX = "\0css:";
+function cssKey(cssPath) {
+  return `${CSS_KEY_PREFIX}${cssPath}`;
+}
+function createResourceRegistry(loader) {
+  const urls = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Map();
+  const refs = /* @__PURE__ */ new Map();
+  const open = /* @__PURE__ */ new Set();
+  let nextGeneration = 1;
+  let epoch = 0;
+  function retain(archivePath) {
+    if (open.size === 0) return false;
+    const holders = refs.get(archivePath) ?? /* @__PURE__ */ new Set();
+    for (const id of open) holders.add(id);
+    refs.set(archivePath, holders);
+    return true;
+  }
+  function release(archivePath) {
+    const url = urls.get(archivePath);
+    if (url !== void 0) {
+      URL.revokeObjectURL(url);
+      urls.delete(archivePath);
+    }
+    refs.delete(archivePath);
+  }
+  return {
+    get size() {
+      return urls.size;
+    },
+    read(archivePath, options) {
+      return loader(archivePath, options);
+    },
+    async resolve(archivePath, options) {
+      const managed = retain(archivePath);
+      const cached = urls.get(archivePath);
+      if (cached !== void 0) return cached;
+      const inFlight = pending.get(archivePath);
+      if (inFlight !== void 0) return inFlight;
+      const myEpoch = epoch;
+      const task = (async () => {
+        const bytes = await loader(archivePath, options);
+        if (bytes === void 0) {
+          if (managed) refs.delete(archivePath);
+          return void 0;
+        }
+        const url = URL.createObjectURL(new Blob([toBlobPart(bytes)]));
+        if (myEpoch !== epoch) {
+          URL.revokeObjectURL(url);
+          return void 0;
+        }
+        if (managed && (refs.get(archivePath)?.size ?? 0) === 0) {
+          URL.revokeObjectURL(url);
+          return void 0;
+        }
+        urls.set(archivePath, url);
+        return url;
+      })().finally(() => {
+        pending.delete(archivePath);
+      });
+      pending.set(archivePath, task);
+      return task;
+    },
+    resolveCss(cssPath, cssText) {
+      const key = cssKey(cssPath);
+      retain(key);
+      const cached = urls.get(key);
+      if (cached !== void 0) return cached;
+      const url = URL.createObjectURL(new Blob([cssText], { type: "text/css" }));
+      urls.set(key, url);
+      return url;
+    },
+    beginGeneration() {
+      const id = nextGeneration;
+      nextGeneration += 1;
+      open.add(id);
+      return id;
+    },
+    endGeneration(generation) {
+      if (!open.delete(generation)) return;
+      for (const [archivePath, holders] of refs) {
+        if (!holders.delete(generation)) continue;
+        if (holders.size === 0) release(archivePath);
+      }
+    },
+    dispose() {
+      epoch += 1;
+      open.clear();
+      refs.clear();
+      for (const url of urls.values()) {
+        URL.revokeObjectURL(url);
+      }
+      urls.clear();
+    }
+  };
+}
+function toBlobPart(bytes) {
+  return bytes.buffer instanceof ArrayBuffer ? new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength) : new Uint8Array(bytes);
+}
+var DOCUMENT_URL_TARGETS = [
+  { selector: "img[src]", attribute: "src" },
+  { selector: "link[href]", attribute: "href" },
+  { selector: "video[poster]", attribute: "poster" },
+  { selector: "video[src]", attribute: "src" },
+  { selector: "audio[src]", attribute: "src" },
+  { selector: "source[src]", attribute: "src" },
+  { selector: "track[src]", attribute: "src" }
+];
+var SRCSET_TARGETS = ["img[srcset]", "source[srcset]"];
+async function rewriteSrcset(raw, registry, options) {
+  const candidates = raw.split(",").map((candidate) => candidate.trim()).filter((candidate) => candidate !== "");
+  const out = [];
+  const missing = [];
+  let rewritten = 0;
+  for (const candidate of candidates) {
+    const spaceAt = candidate.search(/\s/);
+    const rawUrl = spaceAt === -1 ? candidate : candidate.slice(0, spaceAt);
+    const descriptor = spaceAt === -1 ? "" : candidate.slice(spaceAt);
+    const archivePath = resolveArchiveReference(rawUrl, options.sourcePath);
+    if (archivePath === void 0) {
+      out.push(candidate);
+      continue;
+    }
+    const url = await registry.resolve(archivePath, options);
+    if (url === void 0) {
+      missing.push(archivePath);
+      out.push(candidate);
+      continue;
+    }
+    out.push(`${url}${descriptor}`);
+    rewritten += 1;
+  }
+  return { value: out.join(", "), changed: rewritten > 0, rewritten, missing };
+}
+async function rewriteDocumentUrls(doc, registry, options) {
+  let rewritten = 0;
+  const missing = [];
+  for (const { selector, attribute } of DOCUMENT_URL_TARGETS) {
+    for (const element of doc.querySelectorAll(selector)) {
+      const raw = element.getAttribute(attribute);
+      if (raw === null) continue;
+      const archivePath = resolveArchiveReference(raw, options.sourcePath);
+      if (archivePath === void 0) continue;
+      const url = await registry.resolve(archivePath, options);
+      if (url === void 0) {
+        missing.push(archivePath);
+        continue;
+      }
+      element.setAttribute(attribute, url);
+      rewritten += 1;
+    }
+  }
+  for (const selector of SRCSET_TARGETS) {
+    for (const element of doc.querySelectorAll(selector)) {
+      const raw = element.getAttribute("srcset");
+      if (raw === null) continue;
+      const result = await rewriteSrcset(raw, registry, options);
+      if (result.changed) element.setAttribute("srcset", result.value);
+      rewritten += result.rewritten;
+      missing.push(...result.missing);
+    }
+  }
+  return { rewritten, missing };
+}
+async function rewriteStylesheetLinks(doc, registry, options) {
+  let rewritten = 0;
+  const missing = [];
+  for (const element of doc.querySelectorAll(STYLESHEET_LINK_SELECTOR)) {
+    if (!hasStylesheetRel(element)) continue;
+    const raw = element.getAttribute("href");
+    if (raw === null) continue;
+    const archivePath = resolveArchiveReference(raw, options.sourcePath);
+    if (archivePath === void 0) continue;
+    const url = await stylesheetUrl(archivePath, registry, options, /* @__PURE__ */ new Set(), missing);
+    if (url === void 0) {
+      missing.push(archivePath);
+      continue;
+    }
+    element.setAttribute("href", url);
+    rewritten += 1;
+  }
+  return { rewritten, missing };
+}
+var STYLESHEET_LINK_SELECTOR = "link[href]";
+function hasStylesheetRel(element) {
+  const rel = element.getAttribute("rel");
+  if (rel === null) return false;
+  return rel.toLowerCase().split(/\s+/).includes("stylesheet");
+}
+function decodeCss(bytes) {
+  return new TextDecoder().decode(bytes);
+}
+async function stylesheetUrl(archivePath, registry, options, seen, missing) {
+  if (seen.has(archivePath)) return void 0;
+  seen.add(archivePath);
+  const bytes = await registry.read(archivePath, options);
+  if (bytes === void 0) return void 0;
+  const nested = await rewriteCss(
+    decodeCss(bytes),
+    registry,
+    { ...options, sourcePath: archivePath },
+    seen
+  );
+  missing.push(...nested.report.missing);
+  return registry.resolveCss(archivePath, nested.css);
+}
+function collectCssReferences(css) {
+  const references = [];
+  const claimed = [];
+  const importStringPattern = /@import\s+("[^"]*"|'[^']*')/gi;
+  css.replace(importStringPattern, (whole, inner, offset) => {
+    const quote = inner.slice(0, 1);
+    references.push({
+      kind: "import",
+      start: offset,
+      end: offset + whole.length,
+      value: inner.slice(1, -1),
+      render: (url) => `@import ${quote}${url}${quote}`
+    });
+    claimed.push({ start: offset, end: offset + whole.length });
+    return whole;
+  });
+  const importUrlPattern = /@import\s+url\(\s*("[^"]*"|'[^']*'|[^)'"\s][^)'"]*)\s*\)/gi;
+  css.replace(importUrlPattern, (whole, inner, offset) => {
+    const quote = inner.startsWith('"') || inner.startsWith("'") ? inner.slice(0, 1) : "";
+    references.push({
+      kind: "import",
+      start: offset,
+      end: offset + whole.length,
+      value: quote === "" ? inner : inner.slice(1, -1),
+      render: (url) => `@import url(${quote}${url}${quote})`
+    });
+    claimed.push({ start: offset, end: offset + whole.length });
+    return whole;
+  });
+  const urlPattern = /url\(\s*("[^"]*"|'[^']*'|[^)'"\s][^)'"]*)\s*\)/gi;
+  css.replace(urlPattern, (whole, inner, offset) => {
+    if (claimed.some((range) => offset >= range.start && offset < range.end)) return whole;
+    const quote = inner.startsWith('"') || inner.startsWith("'") ? inner.slice(0, 1) : "";
+    references.push({
+      kind: "url",
+      start: offset,
+      end: offset + whole.length,
+      value: quote === "" ? inner : inner.slice(1, -1),
+      render: (url) => `url(${quote}${url}${quote})`
+    });
+    return whole;
+  });
+  return references.sort((a, b) => a.start - b.start);
+}
+async function rewriteCss(css, registry, options, seen) {
+  const references = collectCssReferences(css);
+  const edits = [];
+  const missing = [];
+  for (const reference of references) {
+    const archivePath = resolveArchiveReference(reference.value, options.sourcePath);
+    if (archivePath === void 0) continue;
+    const url = reference.kind === "import" ? await stylesheetUrl(archivePath, registry, options, seen, missing) : await registry.resolve(archivePath, options);
+    if (url === void 0) {
+      missing.push(archivePath);
+      continue;
+    }
+    edits.push({ start: reference.start, end: reference.end, text: reference.render(url) });
+  }
+  let result = css;
+  for (const edit of edits.sort((a, b) => b.start - a.start)) {
+    result = result.slice(0, edit.start) + edit.text + result.slice(edit.end);
+  }
+  return { css: result, report: { rewritten: edits.length, missing } };
+}
+
+// src/render/default/index.ts
+var THEMES = {
+  light: { color: "#1a1a1a", background: "#ffffff" },
+  dark: { color: "#e6e6e6", background: "#121212" }
+};
+var DEFAULT_FONT_SIZE_PX = 16;
+var DEFAULT_LINE_HEIGHT = 1.5;
+var DEFAULT_THEME = "light";
+function resolveAppearance(appearance = {}) {
+  const theme = appearance.theme ?? DEFAULT_THEME;
+  const colors = THEMES[theme];
+  if (colors === void 0) {
+    throw new StateError(
+      `\u672A\u77E5\u4E3B\u9898\u540D ${String(theme)} \u2014\u2014 \u5185\u7F6E\u4E3B\u9898\u53EA\u6709 ${Object.keys(THEMES).join(" / ")}`
+    );
+  }
+  const fontSizePx = appearance.fontSizePx ?? DEFAULT_FONT_SIZE_PX;
+  if (!Number.isFinite(fontSizePx) || fontSizePx <= 0) {
+    throw new StateError(
+      `fontSizePx \u5FC5\u987B\u662F\u6709\u9650\u6B63\u6570\uFF0C\u6536\u5230 ${String(fontSizePx)} \u2014\u2014 0 \u6216\u8D1F\u5B57\u53F7\u8BA9\u5185\u5BB9\u4E0D\u53EF\u8BFB\uFF0CNaN / Infinity \u8BA9\u6574\u4EFD\u6392\u7248\u5931\u6548`
+    );
+  }
+  const lineHeight = appearance.lineHeight ?? DEFAULT_LINE_HEIGHT;
+  if (!Number.isFinite(lineHeight) || lineHeight <= 0) {
+    throw new StateError(
+      `lineHeight \u5FC5\u987B\u662F\u6709\u9650\u6B63\u6570\uFF0C\u6536\u5230 ${String(lineHeight)} \u2014\u2014 \u540C\u4E0A\uFF1A\u884C\u8DDD\u4E3A 0 \u4F1A\u8BA9\u884C\u53E0\u5728\u4E00\u8D77\uFF0CNaN \u4F1A\u8BA9\u6574\u4EFD\u6392\u7248\u5931\u6548`
+    );
+  }
+  return {
+    theme,
+    color: colors.color,
+    background: colors.background,
+    fontSizePx,
+    lineHeight
+  };
+}
+function appearanceDeclarations(appearance) {
+  return [
+    ["color", appearance.color],
+    ["background-color", appearance.background],
+    ["font-size", `${String(appearance.fontSizePx)}px`],
+    ["line-height", String(appearance.lineHeight)]
+  ];
+}
+function pageScrollLeft(page, metrics) {
+  const offset = page * metrics.pageWidth;
+  return metrics.mirrored ? -offset : offset;
+}
+function applyAppearance(doc, appearance) {
+  const style = doc.documentElement.style;
+  for (const [property, value] of appearanceDeclarations(appearance)) {
+    style.setProperty(property, value);
+  }
+}
+function elementOfTarget(doc, target) {
+  if (target.cfi !== void 0) return locateCfi(doc.documentElement, target.cfi)?.element;
+  if (target.fragment !== void 0) return doc.getElementById(target.fragment) ?? void 0;
+  return void 0;
+}
+function pageOfTarget(doc, target, metrics) {
+  const element = elementOfTarget(doc, target);
+  if (element === void 0) return 0;
+  return pageOfElement(element, metrics);
+}
+function withLivenessGate(inner, assertAlive) {
+  return {
+    get size() {
+      return inner.size;
+    },
+    // ⚠️ 声明为 `async`：返回 Promise 的函数**同步抛出**会让 `await` 与 `.rejects`
+    // 两种写法行为不一致（`mount()` 里同一处纪律，契约测试钉的是后者）。
+    async read(archivePath, options) {
+      assertAlive();
+      return inner.read(archivePath, options);
+    },
+    async resolve(archivePath, options) {
+      assertAlive();
+      return inner.resolve(archivePath, options);
+    },
+    // 同步契约 ⇒ 同步抛出。
+    resolveCss(cssPath, cssText) {
+      assertAlive();
+      return inner.resolveCss(cssPath, cssText);
+    },
+    // 代次与释放是**记账**，不创建资源；迟到的 `endGeneration` 只会更保守，不泄漏。
+    beginGeneration() {
+      return inner.beginGeneration();
+    },
+    endGeneration(generation) {
+      inner.endGeneration(generation);
+    },
+    dispose() {
+      inner.dispose();
+    }
+  };
+}
+function applyPagedScroll(doc, page, metrics) {
+  doc.documentElement.scrollLeft = pageScrollLeft(page, metrics);
+}
+function assertScrolledSupported(paginator, nextMode) {
+  if (nextMode !== "scrolled") return;
+  if (paginator === void 0 || !paginator.verticalWriting) return;
+  throw new StateError(
+    "\u6EDA\u52A8\u6A21\u5F0F\u5C1A\u4E0D\u652F\u6301\u7AD6\u6392\u5185\u5BB9 \u2014\u2014 \u7AD6\u6392\u7684\u6EDA\u52A8\u8F74\u4E0E\u671D\u5411\u672A\u53D6\u8BC1\uFF0C\u5B81\u53EF\u62D2\u7EDD\u4E5F\u4E0D\u9759\u9ED8\u6EDA\u5230\u9519\u8BEF\u7684\u65B9\u5411\uFF08FI-X23\uFF09"
+  );
+}
+function applyScrolled(doc, target) {
+  const root = doc.documentElement;
+  const element = elementOfTarget(doc, target);
+  if (element === void 0) {
+    root.scrollTop = 0;
+    return;
+  }
+  root.scrollTop = root.scrollTop + element.getBoundingClientRect().top - root.getBoundingClientRect().top;
+}
+function applyScroll(doc, target, metrics) {
+  if (metrics === void 0) {
+    applyScrolled(doc, target);
+    return;
+  }
+  applyPagedScroll(doc, pageOfTarget(doc, target, metrics), metrics);
+}
+function createDefaultRenderer(options) {
+  const { loadChapter, loadResource, language, direction } = options;
+  let mode = options.mode ?? "paginated";
+  if (typeof loadChapter !== "function") {
+    throw new StateError(
+      "createDefaultRenderer() \u9700\u8981 loadChapter \u2014\u2014 \u6E32\u67D3\u5C42\u523B\u610F\u4E0D\u5185\u5EFA\u5F52\u6863\u8BFB\u53D6\uFF08\u90A3\u662F formats/ \u7684\u804C\u8D23\uFF0CARCHITECTURE \xA71 \u4F9D\u8D56\u65B9\u5411\u5355\u5411\uFF09"
+    );
+  }
+  let appearance = resolveAppearance(options.appearance);
+  let buffer;
+  let view;
+  let teardowns = 0;
+  let liveSince;
+  const registry = loadResource === void 0 ? void 0 : withLivenessGate(createResourceRegistry(loadResource), () => {
+    if (liveSince === void 0 || liveSince === teardowns) return;
+    throw new StateError(
+      "\u672C\u6B21\u6E32\u67D3\u6240\u5C5E\u7684\u89C6\u56FE\u5DF2\u91CA\u653E\uFF0C\u4E0D\u518D\u89E3\u6790\u8D44\u6E90 \u2014\u2014 \u6CE8\u518C\u8868\u5DF2\u7ECF dispose() \u8FC7\uFF0C\u6B64\u523B\u518D\u5EFA `blob:` URL \u5C31\u843D\u8FDB\u4E00\u5F20\u65E0\u4EBA\u8D1F\u8D23\u7684\u8868\u91CC\uFF08FI-X20\uFF1A\u672A revoke \u7684 ObjectURL \u81EA\u5E26\u5F3A\u5F15\u7528\uFF0CGC \u6551\u4E0D\u56DE\u6765\uFF09"
+    );
+  });
+  function teardown() {
+    view?.paginator.dispose();
+    view = void 0;
+    buffer?.dispose();
+    buffer = void 0;
+    registry?.dispose();
+    teardowns += 1;
+  }
+  return {
+    get metrics() {
+      return view?.metrics;
+    },
+    get resourceCount() {
+      return registry?.size ?? 0;
+    },
+    mount(host, mountOptions = {}) {
+      return Promise.resolve().then(() => {
+        throwIfAborted(mountOptions.signal);
+        teardown();
+        buffer = createFrameBuffer(host);
+      });
+    },
+    async render(target, renderOptions = {}) {
+      const active = buffer;
+      if (active === void 0) {
+        throw new StateError(
+          "render() \u4E4B\u524D\u5FC5\u987B\u5148 mount() \u2014\u2014 \u6CA1\u6709\u5BBF\u4E3B\u5C31\u6CA1\u6709\u53EF\u6302\u8F7D\u7684\u89C6\u56FE\uFF0C\u9759\u9ED8\u4EC0\u4E48\u90FD\u4E0D\u505A\u4F1A\u8BA9\u8C03\u7528\u65B9\u4EE5\u4E3A\u5DF2\u7ECF\u6E32\u67D3\u6210\u529F"
+        );
+      }
+      const { signal } = renderOptions;
+      throwIfAborted(signal);
+      const html = await loadChapter(target);
+      throwIfAborted(signal);
+      const frame = active.hidden;
+      const loadOptions = {
+        ...renderOptions,
+        ...language === void 0 ? {} : { language },
+        ...direction === void 0 ? {} : { direction }
+      };
+      const doc = await active.load(frame, html, loadOptions);
+      throwIfAborted(signal);
+      liveSince = teardowns;
+      const generation = registry?.beginGeneration();
+      try {
+        if (registry !== void 0) {
+          const rewriteOptions = { sourcePath: target.href, ...renderOptions };
+          await rewriteStylesheetLinks(doc, registry, rewriteOptions);
+          await rewriteDocumentUrls(doc, registry, rewriteOptions);
+          await active.waitForLayout(frame, renderOptions);
+          throwIfAborted(signal);
+        }
+        const paginator = createPaginator(doc, { mode });
+        applyAppearance(doc, appearance);
+        assertScrolledSupported(paginator, mode);
+        const metrics = mode === "paginated" ? paginator.measure(renderOptions) : void 0;
+        const previous = view;
+        view = { doc, paginator, target, metrics, generation };
+        applyScroll(doc, target, metrics);
+        active.swap();
+        if (previous !== void 0) {
+          previous.paginator.dispose();
+          if (previous.generation !== void 0) registry?.endGeneration(previous.generation);
+        }
+      } catch (error) {
+        if (generation !== void 0 && view?.generation !== generation) {
+          registry?.endGeneration(generation);
+        }
+        throw error;
+      }
+    },
+    setAppearance(nextAppearance) {
+      const resolved = resolveAppearance(nextAppearance);
+      appearance = resolved;
+      const active = view;
+      if (active === void 0) return;
+      applyAppearance(active.doc, resolved);
+      if (active.metrics !== void 0) {
+        active.metrics = active.paginator.measure();
+      }
+      applyScroll(active.doc, active.target, active.metrics);
+    },
+    setMode(nextMode) {
+      if (nextMode === mode) return;
+      assertScrolledSupported(view?.paginator, nextMode);
+      mode = nextMode;
+      const active = view;
+      if (active === void 0) return;
+      active.paginator.setMode(nextMode);
+      active.metrics = nextMode === "paginated" ? active.paginator.measure() : void 0;
+      applyScroll(active.doc, active.target, active.metrics);
+    },
+    unmount() {
+      teardown();
+    }
+  };
+}
+
+export { DEFAULT_FONT_SIZE_PX, DEFAULT_LINE_HEIGHT, DEFAULT_THEME, THEMES, appearanceDeclarations, createDefaultRenderer, pageScrollLeft, resolveAppearance };