frond-js 0.4.0

package/dist/index.cjs

@@ -0,0 +1,655 @@
+'use strict';
+
+var chunkGTGLDLJD_cjs = require('./chunk-GTGLDLJD.cjs');
+var chunkWCZTTQ7Z_cjs = require('./chunk-WCZTTQ7Z.cjs');
+var chunk2SUG7YFZ_cjs = require('./chunk-2SUG7YFZ.cjs');
+var chunkSLI2YL25_cjs = require('./chunk-SLI2YL25.cjs');
+require('./chunk-IIV6VIUJ.cjs');
+var chunkG7DLWGBW_cjs = require('./chunk-G7DLWGBW.cjs');
+
+// src/core/formats/registry.ts
+function createFormatRegistry(loaders) {
+  return {
+    async open(source, options = {}) {
+      chunkG7DLWGBW_cjs.throwIfAborted(options.signal);
+      const bytes = await chunkWCZTTQ7Z_cjs.resolveBookBytes(source, options);
+      const label = options.source ?? "<anonymous>";
+      const outcome = chunk2SUG7YFZ_cjs.probeFormat(bytes.subarray(0, chunk2SUG7YFZ_cjs.PROBE_PREFIX_BYTES));
+      if (outcome === null) {
+        throw new chunkG7DLWGBW_cjs.FormatError(
+          `\u65E0\u6CD5\u8BC6\u522B\u7684\u4E66\u7C4D\u683C\u5F0F\uFF1A\u524D ${String(chunk2SUG7YFZ_cjs.PROBE_PREFIX_BYTES)} \u5B57\u8282\u4E0D\u5339\u914D\u4EFB\u4F55\u5DF2\u77E5\u5224\u636E\uFF08\u6E90: ${label}\uFF09`
+        );
+      }
+      const hit = outcome.kind === "format" ? outcome : probeContainer(bytes, options, label);
+      const loader = loaders[hit.format];
+      if (loader === void 0) {
+        throw new chunkG7DLWGBW_cjs.FormatError(
+          `\u8BC6\u522B\u4E3A ${hit.format}\uFF08\u5224\u636E\uFF1A${hit.evidence}\uFF09\uFF0C\u4F46\u8BE5\u683C\u5F0F\u7684\u9002\u914D\u5668\u5C1A\u672A\u5B9E\u73B0\uFF08\u6E90: ${label}\uFF09`
+        );
+      }
+      const adapter = await loader();
+      chunkG7DLWGBW_cjs.throwIfAborted(options.signal);
+      return adapter.open(bytes, options);
+    }
+  };
+}
+function probeContainer(bytes, options, label) {
+  const archive = chunkSLI2YL25_cjs.parseZip(bytes, options);
+  const hit = chunk2SUG7YFZ_cjs.probeZipContainer(archive.entries.map((entry) => entry.name));
+  if (hit === null) {
+    throw new chunkG7DLWGBW_cjs.FormatError(
+      `ZIP \u5BB9\u5668\u65E2\u65E0 ${chunk2SUG7YFZ_cjs.EPUB_CONTAINER_ENTRY}\uFF0C\u4E5F\u65E0\u56FE\u7247 / .fb2 \u6761\u76EE\uFF0C\u65E0\u6CD5\u5224\u5B9A\u683C\u5F0F\uFF08\u6E90: ${label}\uFF09`
+    );
+  }
+  return hit;
+}
+
+// src/reader/state.ts
+var READER_STATES = [
+  "idle",
+  "loading",
+  "ready",
+  "paginating",
+  "error",
+  "closed"
+];
+var TRANSITIONS = {
+  idle: ["loading", "closed"],
+  loading: ["ready", "error", "closed"],
+  ready: ["paginating", "closed"],
+  paginating: ["ready", "error", "closed"],
+  error: ["loading", "closed"],
+  closed: []
+};
+function canTransition(from, to) {
+  return TRANSITIONS[from].includes(to);
+}
+var ReaderStateMachine = class {
+  #state = "idle";
+  #listeners = /* @__PURE__ */ new Set();
+  /** 当前状态。 */
+  get state() {
+    return this.#state;
+  }
+  /** 是否已进入终态。 */
+  get isTerminal() {
+    return this.#state === "closed";
+  }
+  /**
+   * 执行一次状态迁移。
+   *
+   * @throws {StateError} 迁移不在 {@link TRANSITIONS} 中时
+   */
+  transition(to) {
+    const from = this.#state;
+    if (!canTransition(from, to)) {
+      throw new chunkG7DLWGBW_cjs.StateError(`\u975E\u6CD5\u72B6\u6001\u8FC1\u79FB\uFF1A${from} \u2192 ${to}`);
+    }
+    this.#state = to;
+    this.#emit(to);
+    return to;
+  }
+  /** 订阅状态变化，返回取消订阅函数（幂等）。 */
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => {
+      this.#listeners.delete(listener);
+    };
+  }
+  #emit(state) {
+    for (const listener of [...this.#listeners]) {
+      listener(state);
+    }
+  }
+};
+
+// src/reader/formats.ts
+var DEFAULT_FORMAT_LOADERS = {
+  epub: async () => (await import('./adapter-DF34GBWJ.cjs')).epubAdapter,
+  // MOBI（T3.2a）：与 EPUB 同一套规矩 —— 深路径进 `adapter.js`（**不是** subpath
+  // 入口），本批**不**为 MOBI 新开 `frond-js/formats/mobi` 公开入口。理由与代价
+  // 见上面那段（0.24 KB gzip 换「不发布一个消费者无法命名其类型的公共 API」）。
+  //
+  // ⚠️ 探测侧**不需要**改：`core/formats/probe.ts` 早已按 PalmDB 头 offset 60 的
+  // `BOOKMOBI` 标记判出 `'mobi'`（T3.0.3 就绪，本批只是把 thunk 补上）。
+  // 也就是说「认得出但没实现」这条路径**被本行关掉了** —— 在此之前，一个 MOBI
+  // 文件会走到注册表的「尚未实现」分支；现在它会真的被打开。
+  mobi: async () => (await import('./adapter-ZRNSDQUV.cjs')).mobiAdapter,
+  // FB2（T3.3）：与前两者同一套规矩 —— 深路径进 `adapter.js`（**不是** subpath 入口），
+  // 本批**不**为 FB2 新开 `frond-js/formats/fb2` 公开入口。理由与代价见上面那段。
+  //
+  // ⚠️ 探测侧**不需要**改：`core/formats/probe.ts` 早已就绪两级判据 ——
+  // 一级 `looksLikeFb2`（BOM / 前置空白容忍 + 前缀含 `<FictionBook`），
+  // 二级 `probeZipContainer` 的 `.fb2.zip`（ZIP 内含 `.fb2` 且无 `container.xml`）。
+  // 也就是说「认得出但没实现」这条路径**被本行关掉了**。
+  fb2: async () => (await import('./adapter-3G46J3CA.cjs')).fb2Adapter,
+  // CBZ（T3.4）：与前四者同一套规矩 —— 深路径进 `adapter.js`（**不是** subpath 入口），
+  // 本批**不**为 CBZ 新开 `frond-js/formats/cbz` 公开入口。理由与代价见上面那段。
+  //
+  // ⚠️ 探测侧**不需要**改：`core/formats/probe.ts` 的 `probeZipContainer` 早已就绪
+  // 第三条判据（ZIP 内含 `IMAGE_EXTENSIONS` 里的扩展名，且无 `container.xml`、无 `.fb2`）。
+  // 也就是说「认得出但没实现」这条路径**被本行关掉了**。
+  //
+  // ⚠️ **与 FB2 / MOBI 的差别**：CBZ **没有裸文件形态**（它必是 ZIP）⇒ 只走**二级**探测
+  // 那一条入口，`probeFormat`（一级、按魔数）永远判不出它。故 `cbz-adapter.test.ts`
+  // 比 `fb2-adapter.test.ts` 少一组用例 —— 少的那组不是漏了，是**不存在**。
+  cbz: async () => (await import('./adapter-EXTNILTC.cjs')).cbzAdapter,
+  // PDF（T3.5）：与前五者同一套规矩 —— 深路径进 `adapter.js`（**不是** subpath 入口），
+  // 本批**不**为 PDF 新开 `frond-js/formats/pdf` 公开入口。理由与代价见上面那段。
+  //
+  // ⚠️ 探测侧**不需要**改：`core/formats/probe.ts` 的 `probeFormat` 早已就绪
+  // **第一条判据**（`%PDF-` 魔数 @ offset 0，**一级**、不需要容器）。也就是说
+  // 「认得出但没实现」这条路径**被本行关掉了**。
+  //
+  // ⚠️ **与 CBZ / FB2 / MOBI 的差别**：PDF 是**单文件**，探测走一级判据
+  // ⇒ `pdf-adapter.test.ts` 里那组「容器内条目名」的用例**不存在**（不是漏了）。
+  //
+  // ⚠️ 本行是「格式包不进根入口闭包」在 PDF 上的落点：`adapter.js` 里那个字面量
+  // `import('pdfjs-dist/legacy/build/pdf.mjs')` 是本包对 PDF.js 的**唯一引用**，
+  // `tsup` 按 `peerDependencies` 把它判为 external ⇒ PDF.js **不进 `dist/`**。
+  // 这条机制已由受控对照确证（移除 peer 声明 ⇒ 836.17 KB 被内联），且**接线后复测过**。
+  pdf: async () => (await import('./adapter-LRJTQ47I.cjs')).pdfAdapter
+};
+
+// src/reader/render-layer.ts
+var DEFAULT_RENDER_LOADERS = {
+  default: async () => (await import('./default-UK52WOO5.cjs')).createDefaultRenderer
+};
+function prefetchDefaultRenderer() {
+  DEFAULT_RENDER_LOADERS.default().catch(() => void 0);
+}
+
+// src/reader/navigation.ts
+function locationAt(book, index, cfi) {
+  const chapter = Number.isInteger(index) ? book.chapters[index] : void 0;
+  if (chapter === void 0) {
+    throw new RangeError(
+      `\u7AE0\u7D22\u5F15\u8D8A\u754C\uFF1A${String(index)}\uFF08\u672C\u4E66\u5171 ${String(book.chapters.length)} \u7AE0\uFF09`
+    );
+  }
+  return cfi === void 0 ? { href: chapter.href, index } : { href: chapter.href, index, cfi };
+}
+function locationForTocItem(book, item) {
+  const index = book.chapters.findIndex((chapter) => chapter.href === item.href);
+  if (index < 0) {
+    throw new chunkG7DLWGBW_cjs.FormatError(
+      `\u76EE\u5F55\u9879\u7684\u76EE\u6807\u4E0D\u5728\u9605\u8BFB\u987A\u5E8F\u91CC\uFF1A${item.href}\uFF08\u672C\u4E66\u5171 ${String(book.chapters.length)} \u7AE0\uFF09`
+    );
+  }
+  const fragment = item.fragment?.trim() ?? "";
+  if (fragment === "") return { href: item.href, index };
+  if (fragment.startsWith("epubcfi(") || fragment.startsWith("/")) {
+    return { href: item.href, index, cfi: chunkGTGLDLJD_cjs.parseCfi(fragment) };
+  }
+  return { href: item.href, index, fragment };
+}
+function neighbourIndex(book, from, direction) {
+  let found;
+  for (let index = 0; index < book.chapters.length; index += 1) {
+    if (book.chapters[index]?.linear !== true) continue;
+    if (direction === 1) {
+      if (index > from) return index;
+    } else if (index < from) {
+      found = index;
+    }
+  }
+  return found;
+}
+
+// src/reader/open-options.ts
+function buildFormatOpenOptions(input) {
+  const { signal, source, pdf } = input;
+  return {
+    signal,
+    ...source === void 0 ? {} : { source },
+    ...pdf === void 0 ? {} : { pdf }
+  };
+}
+
+// src/reader/reader.ts
+var DEFAULT_REGISTRY = createFormatRegistry(DEFAULT_FORMAT_LOADERS);
+var Reader = class {
+  #options;
+  #machine = new ReaderStateMachine();
+  /**
+   * 当前会话 —— 渲染器 + 已解析的书 + 当前章索引。
+   *
+   * **合成一个对象而不是几个并列字段**（与 `render/default/index.ts` 的
+   * `ViewState` 同一理由）：并列时「有渲染器但没有书」这类中间态在类型上合法，
+   * 于是每个用到它们的地方都要写一遍判空，而那些判空**永远不可达**。
+   *
+   * 它是**资源句柄**，不是状态标志位 —— 生命周期仍由状态机表达（H5）。
+   */
+  #session;
+  /**
+   * 操作代次。`open()` 开始时自增，`close()` 也自增。
+   *
+   * 用途：让**在飞操作**知道自己是否已被 `close()` 接管。没有它，一次
+   * 「`close()` 之后 `open()` 才落地」会去执行 `closed → ready` —— 非法迁移，
+   * 于是把一次正常的取消变成契约外的 `StateError`。
+   */
+  #generation = 0;
+  /** 当前在飞操作的取消控制器（`close()` 借它中止它们）。 */
+  #controller;
+  constructor(options = {}) {
+    this.#options = options;
+  }
+  /** 当前状态。只读 —— 只能由内部状态机迁移（H5）。 */
+  get state() {
+    return this.#machine.state;
+  }
+  /**
+   * 当前书的目录树（按文档顺序）。无目录时为空数组。
+   *
+   * ## 为什么这个 getter 存在（T3.2b ③c 立项，ADR-0011 修订）
+   *
+   * 本节顶部的「刻意不提供的接口」原先写着**不暴露** `toc`。本批**改这条决定**，
+   * 理由是：**目录不可达就等于没有目录** —— `Reader` 的公开面原先**没有任何路径**
+   * 能让调用方拿到目录（`book` 也没暴露），于是「目录可跳转」这条需求在
+   * `Reader` 上**无法被调用方实现**（只能绕过门面直接用 `openBook` + 自备渲染器）。
+   * 现在有了 `toc` + {@link goTo} 的 `TocItem` 形态，这条链路才闭合。
+   *
+   * ⚠️ **只加这一个**：`book` / `currentLocation` 仍**不暴露** —— 它们各自都还没有
+   * 「调用方非拿到不可」的场景，而 `toc` 有。**未登记的能力不得擅自扩大公共面**（H13）。
+   *
+   * ## 前置条件：必须 `ready`
+   *
+   * 非 `ready` 时抛 `StateError`，**不返回空数组** —— 空数组与「这本书确实没有目录」
+   * 在类型上无法区分，返回它就是把**假信息**交给调用方（同 `locationAt` 的
+   * 「共 0 项」那条注释）。目录在 `open` 成功时一次性产出，`close` 后随会话一起释放。
+   *
+   * 返回的数组是**适配器产出的原对象**（不复制、不冻结）：`TocItem` 是只读契约，
+   * 复制一份既无收益，又会让「同一个目录项对象」在两次读取间不是同一个引用。
+   *
+   * @throws {StateError} 当前状态不是 `ready`
+   */
+  get toc() {
+    return this.#requireReadySession().opened.toc;
+  }
+  /**
+   * 打开一本书。`idle → loading → ready`，失败则 `loading → error`。
+   *
+   * 输入归一化（`BookInput` 五种形态）：`ArrayBuffer` / `Uint8Array` / `BookSource`
+   * 直接交给格式注册表（不复制）；`Blob` 走 `arrayBuffer()`；`string` 按 **URL**
+   * 走 `fetch`。格式的判别（探测）与适配器的加载都在注册表里完成 —— 本方法
+   * 对「这是什么格式」一无所知（ADR-0013）。
+   *
+   * 打开成功后**立即渲染落点**：默认落到第 0 章（`Book.chapters[0]`），传了
+   * `ReaderOptions.initialLocation` 则落到该 CFI 所指的章与章内位置。
+   *
+   * @throws {StateError} 当前状态不是 `idle` / `error`，或 `ReaderOptions.host` 缺失
+   * @throws {ParseError} container / OPF / 目录文档 XML 结构损坏
+   * @throws {FormatError} 认不出格式、该格式的适配器尚未实现、归档结构非法、
+   *   OPF 语义违规，或 `initialLocation` 无法解释为书内位置
+   * @throws {NetworkError} `string` 输入的 URL 取字节失败（非 2xx / 网络错误）
+   * @throws {AbortError} 操作被取消 —— **状态转 `closed`**，已分配资源全部释放
+   */
+  async open(input, options = {}) {
+    if (!canTransition(this.#machine.state, "loading")) {
+      throw new chunkG7DLWGBW_cjs.StateError(
+        `Reader.open() \u53EA\u5141\u8BB8\u5728 idle / error \u72B6\u6001\u8C03\u7528\uFF0C\u5F53\u524D\u662F ${this.#machine.state}`
+      );
+    }
+    const host = this.#options.host;
+    if (host === void 0) {
+      throw new chunkG7DLWGBW_cjs.StateError("Reader.open() \u9700\u8981 ReaderOptions.host \u2014\u2014 \u6CA1\u6709\u5BBF\u4E3B\u5C31\u6CA1\u6709\u53EF\u6302\u8F7D\u7684\u89C6\u56FE");
+    }
+    const startCfi = resolveStartCfi(this.#options.initialLocation);
+    const generation = this.#generation += 1;
+    const controller = new AbortController();
+    this.#controller = controller;
+    const signal = linkOperationSignal(options.signal, controller);
+    this.#machine.transition("loading");
+    let mounted;
+    try {
+      chunkG7DLWGBW_cjs.throwIfAborted(signal);
+      if (this.#options.renderer === void 0) prefetchDefaultRenderer();
+      const opened = await this.#load(input, signal);
+      const renderer = this.#options.renderer ?? await createDefaultRendererFor(opened, this.#options.io);
+      mounted = renderer;
+      chunkG7DLWGBW_cjs.throwIfAborted(signal);
+      await renderer.mount(host, { signal });
+      chunkG7DLWGBW_cjs.throwIfAborted(signal);
+      const index = resolveStartIndex(opened.book, startCfi);
+      await renderer.render(locationAt(opened.book, index, startCfi), { signal });
+      chunkG7DLWGBW_cjs.throwIfAborted(signal);
+      this.#session = { renderer, opened, index };
+      this.#machine.transition("ready");
+    } catch (error) {
+      mounted?.unmount();
+      this.#settle(generation, chunkG7DLWGBW_cjs.isAbortError(error) ? "closed" : "error");
+      throw error;
+    } finally {
+      if (this.#controller === controller) this.#controller = void 0;
+    }
+  }
+  /**
+   * 关闭并释放全部资源。任意非 `closed` 状态 → `closed`；`closed` 为终态，不可复用。
+   *
+   * **幂等且不抛**（`docs/API.md` §3.1）：重复调用无副作用。
+   *
+   * 关闭会**中止在飞操作**（内部 `AbortController`）—— 被中止的 `open` 以其
+   * `AbortError` 拒绝，被中止的 `next` / `prev` / `goTo` 同样；两者的状态落点
+   * 都由迁移表决定（`loading → closed` / `paginating → closed`）。
+   *
+   * 只有**已挂载过**的渲染器会收到 `unmount()` —— 从未打开过时（`idle` 下
+   * 直接 `close()`）没有要释放的东西，不会去打扰调用方传入的自定义渲染器。
+   */
+  close() {
+    if (this.#machine.state === "closed") return;
+    this.#generation += 1;
+    const controller = this.#controller;
+    this.#controller = void 0;
+    controller?.abort();
+    this.#machine.transition("closed");
+    const session = this.#session;
+    this.#session = void 0;
+    session?.renderer.unmount();
+  }
+  /**
+   * 下一章。仅 `ready` 状态可调用。
+   *
+   * **「下一章」= 从当前章索引向后第一个 `linear === true` 的章**
+   * （`linear="no"` 是封面 / 版权页这类辅助内容，不进阅读顺序）。
+   * 后面没有线性项时是**合法的 no-op**：不迁移、不抛、不再渲染 ——
+   * `docs/API.md` §3.1 没有给 `next` 登记 `RangeError`，且迁移表里没有
+   * `ready → ready` 这条边，两条合起来只允许「什么都不做」。
+   *
+   * @throws {StateError} 当前状态不是 `ready`
+   * @throws {AbortError} 操作被取消 —— **状态回 `ready`**，双缓冲不残留
+   */
+  async next(options = {}) {
+    await this.#navigate((session) => {
+      const index = neighbourIndex(session.opened.book, session.index, 1);
+      return index === void 0 ? void 0 : locationAt(session.opened.book, index);
+    }, options);
+  }
+  /**
+   * 上一章。仅 `ready` 状态可调用。
+   *
+   * 与 {@link Reader.next} 对称：向前第一个 `linear === true` 的项；
+   * 前面没有线性项时是合法的 no-op。
+   *
+   * @throws {StateError} 当前状态不是 `ready`
+   * @throws {AbortError} 操作被取消 —— **状态回 `ready`**
+   */
+  async prev(options = {}) {
+    await this.#navigate((session) => {
+      const index = neighbourIndex(session.opened.book, session.index, -1);
+      return index === void 0 ? void 0 : locationAt(session.opened.book, index);
+    }, options);
+  }
+  /**
+   * 跳转到指定位置。
+   *
+   * 四种目标形态：
+   *
+   * | 目标 | 语义 | 失败时 |
+   * | ---- | ---- | ------ |
+   * | `number` | **章索引**（`Book.chapters` 的下标，`0` 起） | 非整数 / 越界 → `RangeError` |
+   * | `Cfi` / CFI 字符串 | 书内 CFI，**按它的 spine 步推出章**，并作为章内位置 | 字符串不是 CFI，或 CFI 推不出章 → `FormatError`；推出的章号越界 → `RangeError` |
+   * | `TocItem` | **目录项**（T3.2b ③c）：`href` → 章，`fragment` → 章内位置 | `href` 不在阅读顺序里 → `FormatError`（见 {@link locationForTocItem}） |
+   *
+   * **CFI → 章**的推导口径见 {@link spineIndexFromCfi}；**目录项 → 章内位置**
+   * 的口径见 {@link locationForTocItem}（那里也登记了 MOBI 目录项当前
+   * 「落到章首」这个已知缺口）。
+   *
+   * `number` 形态**不检查** `linear` —— 索引直达是显式意图，与「翻页跳过辅助内容」分开。
+   *
+   * 跳到当前所在章**照常重新渲染**（不做特判）：调用方拿到的是同一套
+   * 「渲染完成」保证，不需要自己判断「这算不算真的跳了」。
+   *
+   * @throws {StateError} 当前状态不是 `ready`
+   * @throws {RangeError} 索引越界（含 CFI 推出的章号越界）
+   * @throws {FormatError} 字符串目标不是合法 CFI / CFI 无法映射到书内的章 /
+   *   目录项的 `href` 不在阅读顺序里
+   * @throws {AbortError} 操作被取消 —— **状态回 `ready`**
+   */
+  async goTo(target, options = {}) {
+    await this.#navigate((session) => resolveGoToTarget(session.opened.book, target), options);
+  }
+  /**
+   * 订阅状态变化，返回取消订阅函数。
+   *
+   * 取消函数**幂等**（重复调用无副作用）。监听器抛错**不**影响其他监听器
+   * —— 广播前会复制监听器集合（`state.ts` 已保证）。
+   */
+  subscribe(listener) {
+    return this.#machine.subscribe(listener);
+  }
+  /**
+   * 取当前会话，同时完成 `next` / `prev` / `goTo` / `toc` 的前置检查。
+   *
+   * ⚠️ **两个条件写进同一个 `if`，是刻意的**：拆成两条时，第二条
+   * （「有会话」）在状态机正常工作时**永远走不到** —— `ready` / `paginating`
+   * 状态必然伴随会话。拆开就会留下一条不可达分支（`MEMORY.md` §7：
+   * 真不可达要**消掉它**，而不是标注忽略）。合并之后两个操作数**都有真实路径**：
+   * `idle` 下没有会话，`paginating` 下有会话但状态不对。
+   */
+  #requireReadySession() {
+    const session = this.#session;
+    if (session === void 0 || this.#machine.state !== "ready") {
+      throw new chunkG7DLWGBW_cjs.StateError(
+        `next / prev / goTo / toc \u53EA\u5141\u8BB8\u5728 ready \u72B6\u6001\u8C03\u7528\uFF0C\u5F53\u524D\u662F ${this.#machine.state}`
+      );
+    }
+    return session;
+  }
+  /**
+   * `next` / `prev` / `goTo` 的公共骨架。
+   *
+   * `resolve` 负责「目标从哪来」：`undefined` 表示**端点处没有可去的章**
+   * （合法的 no-op），此时不迁移、不渲染、不抛。
+   *
+   * `resolve` 抛出的 `RangeError` / `FormatError` 也**不会**触发迁移 ——
+   * 它跑在任何迁移之前，非法目标不该把状态推进到 `paginating`。
+   */
+  async #navigate(resolve, options) {
+    const session = this.#requireReadySession();
+    chunkG7DLWGBW_cjs.throwIfAborted(options.signal);
+    const target = resolve(session);
+    if (target === void 0) return;
+    const generation = this.#generation;
+    const controller = new AbortController();
+    this.#controller = controller;
+    const signal = linkOperationSignal(options.signal, controller);
+    this.#machine.transition("paginating");
+    try {
+      await session.renderer.render(target, { signal });
+      chunkG7DLWGBW_cjs.throwIfAborted(signal);
+      session.index = target.index;
+      this.#settle(generation, "ready");
+    } catch (error) {
+      this.#settle(generation, chunkG7DLWGBW_cjs.isAbortError(error) ? "ready" : "error");
+      throw error;
+    } finally {
+      if (this.#controller === controller) this.#controller = void 0;
+    }
+  }
+  /**
+   * 在飞操作结束时的状态落点。
+   *
+   * 代次已变 ⇒ `close()` 已经接管（它把状态带到了 `closed`）。此时**不再迁移**
+   * —— 再迁一次会抛 `StateError`（`closed` 无出边），把一次正常的取消
+   * 变成契约外的错误。
+   */
+  #settle(generation, to) {
+    if (this.#generation === generation) {
+      this.#machine.transition(to);
+    }
+  }
+  /**
+   * `BookInput` → 已解析的书。
+   *
+   * 前四种形态先归一到字节，第五种（`Uint8Array` / `BookSource`）直接交给注册表 ——
+   * 它用 `ArrayBuffer.isView`（跨 realm 安全）自行判别，不劳这里重复一遍。
+   * 格式的判别、适配器的加载与字节源的一次性读取都在注册表里完成。
+   */
+  #load(input, signal) {
+    const openOptions = buildFormatOpenOptions({
+      signal,
+      ...typeof input === "string" ? { source: input } : {},
+      pdf: this.#options.pdf
+    });
+    if (typeof input === "string") {
+      return fetchBookBytes(input, signal).then(
+        (bytes) => DEFAULT_REGISTRY.open(bytes, openOptions)
+      );
+    }
+    if (isBlob(input)) {
+      return input.arrayBuffer().then((buffer) => DEFAULT_REGISTRY.open(new Uint8Array(buffer), openOptions));
+    }
+    if (isArrayBuffer(input)) {
+      return DEFAULT_REGISTRY.open(new Uint8Array(input), openOptions);
+    }
+    return DEFAULT_REGISTRY.open(input, openOptions);
+  }
+};
+function linkOperationSignal(caller, controller) {
+  return caller === void 0 ? controller.signal : AbortSignal.any([controller.signal, caller]);
+}
+function isArrayBuffer(value) {
+  return Object.prototype.toString.call(value) === "[object ArrayBuffer]";
+}
+function isBlob(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value;
+  return typeof candidate.arrayBuffer === "function" && typeof candidate.size === "number";
+}
+async function fetchBookBytes(url, signal) {
+  let response;
+  try {
+    response = await fetch(url, { signal });
+  } catch (error) {
+    if (chunkG7DLWGBW_cjs.isAbortError(error)) throw chunkG7DLWGBW_cjs.createAbortError(error);
+    chunkG7DLWGBW_cjs.throwIfAborted(signal);
+    throw new chunkG7DLWGBW_cjs.NetworkError(`\u83B7\u53D6\u4E66\u6E90\u5931\u8D25\uFF1A${url}`, { cause: error });
+  }
+  chunkG7DLWGBW_cjs.throwIfAborted(signal);
+  if (!response.ok) {
+    throw new chunkG7DLWGBW_cjs.NetworkError(`\u83B7\u53D6\u4E66\u6E90\u5931\u8D25\uFF1A${url}\uFF08HTTP ${String(response.status)}\uFF09`);
+  }
+  return new Uint8Array(await response.arrayBuffer());
+}
+async function createDefaultRendererFor(opened, io) {
+  const { book } = opened;
+  const createDefaultRenderer = await DEFAULT_RENDER_LOADERS.default();
+  return createDefaultRenderer({
+    loadChapter: (target) => opened.content.readText(target.href),
+    loadResource: createResourceLoader(opened, io),
+    language: book.metadata.language,
+    // exactOptionalPropertyTypes：可选字段不能显式传 `undefined` ⇒ 只在有值时加键
+    // （同 `render/default/index.ts` 的 `loadOptions`）。
+    ...book.direction === void 0 ? {} : { direction: book.direction }
+  });
+}
+function createResourceLoader(opened, io) {
+  return async (archivePath, options) => {
+    try {
+      return io === void 0 ? await opened.content.read(archivePath, options) : await io.load(archivePath, options);
+    } catch (error) {
+      if (error instanceof chunkG7DLWGBW_cjs.FormatError) return void 0;
+      throw error;
+    }
+  };
+}
+function resolveStartCfi(location) {
+  if (location === void 0) return void 0;
+  return typeof location === "string" ? parseCfiTarget(location, "ReaderOptions.initialLocation") : location;
+}
+function resolveStartIndex(book, cfi) {
+  if (cfi === void 0) return 0;
+  const index = spineIndexFromCfi(cfi, book);
+  if (index === void 0) {
+    throw new chunkG7DLWGBW_cjs.FormatError(`initialLocation \u7684 CFI \u65E0\u6CD5\u6620\u5C04\u5230 spine \u4E2D\u7684\u7AE0\uFF1A${chunkGTGLDLJD_cjs.serializeCfi(cfi)}`);
+  }
+  return index;
+}
+function resolveGoToTarget(book, target) {
+  if (typeof target === "number") return locationAt(book, target);
+  if (typeof target === "object" && !chunkGTGLDLJD_cjs.isCfi(target)) return locationForTocItem(book, target);
+  const cfi = typeof target === "string" ? parseCfiTarget(target, "goTo") : target;
+  const index = spineIndexFromCfi(cfi, book);
+  if (index === void 0) {
+    throw new chunkG7DLWGBW_cjs.FormatError(`goTo \u7684 CFI \u65E0\u6CD5\u6620\u5C04\u5230 spine \u4E2D\u7684\u7AE0\uFF1A${chunkGTGLDLJD_cjs.serializeCfi(cfi)}`);
+  }
+  return locationAt(book, index, cfi);
+}
+function parseCfiTarget(value, label) {
+  const candidate = value;
+  if (!chunkGTGLDLJD_cjs.isCfiString(candidate)) {
+    throw new chunkG7DLWGBW_cjs.FormatError(`${label} \u7684\u5B57\u7B26\u4E32\u76EE\u6807\u4E0D\u662F\u5408\u6CD5\u7684 CFI\uFF1A${value}`);
+  }
+  return chunkGTGLDLJD_cjs.parseCfi(candidate);
+}
+function spineIndexFromCfi(cfi, book) {
+  const point = cfi.kind === "range" ? cfi.start : cfi;
+  const path = point.paths[0];
+  if (path === void 0) return void 0;
+  const itemref = path.steps[1];
+  if (itemref === void 0) return void 0;
+  if (itemref.id !== void 0) {
+    const byId = book.spine.findIndex((item) => item.idref === itemref.id);
+    if (byId !== -1) return byId;
+  }
+  if (path.steps[0]?.index !== 6) return void 0;
+  const step = itemref.index;
+  if (step < 2 || step % 2 !== 0) return void 0;
+  return step / 2 - 1;
+}
+
+Object.defineProperty(exports, "AbortError", {
+  enumerable: true,
+  get: function () { return chunkG7DLWGBW_cjs.AbortError; }
+});
+Object.defineProperty(exports, "FormatError", {
+  enumerable: true,
+  get: function () { return chunkG7DLWGBW_cjs.FormatError; }
+});
+Object.defineProperty(exports, "FrondError", {
+  enumerable: true,
+  get: function () { return chunkG7DLWGBW_cjs.FrondError; }
+});
+Object.defineProperty(exports, "NetworkError", {
+  enumerable: true,
+  get: function () { return chunkG7DLWGBW_cjs.NetworkError; }
+});
+Object.defineProperty(exports, "ParseError", {
+  enumerable: true,
+  get: function () { return chunkG7DLWGBW_cjs.ParseError; }
+});
+Object.defineProperty(exports, "SecurityError", {
+  enumerable: true,
+  get: function () { return chunkG7DLWGBW_cjs.SecurityError; }
+});
+Object.defineProperty(exports, "StateError", {
+  enumerable: true,
+  get: function () { return chunkG7DLWGBW_cjs.StateError; }
+});
+Object.defineProperty(exports, "createAbortError", {
+  enumerable: true,
+  get: function () { return chunkG7DLWGBW_cjs.createAbortError; }
+});
+Object.defineProperty(exports, "isAbortError", {
+  enumerable: true,
+  get: function () { return chunkG7DLWGBW_cjs.isAbortError; }
+});
+Object.defineProperty(exports, "isFrondError", {
+  enumerable: true,
+  get: function () { return chunkG7DLWGBW_cjs.isFrondError; }
+});
+Object.defineProperty(exports, "linkSignals", {
+  enumerable: true,
+  get: function () { return chunkG7DLWGBW_cjs.linkSignals; }
+});
+Object.defineProperty(exports, "onAbort", {
+  enumerable: true,
+  get: function () { return chunkG7DLWGBW_cjs.onAbort; }
+});
+Object.defineProperty(exports, "throwIfAborted", {
+  enumerable: true,
+  get: function () { return chunkG7DLWGBW_cjs.throwIfAborted; }
+});
+exports.READER_STATES = READER_STATES;
+exports.Reader = Reader;
+exports.canTransition = canTransition;