frond-js 0.4.0

package/dist/adapter-ZM5FQTJT.js

@@ -0,0 +1,1415 @@
+import { throwIfAborted, FormatError, ParseError } from './chunk-B2L2YVXD.js';
+
+// src/formats/mobi/anchors.ts
+var LATIN1 = new TextDecoder("latin1");
+var ASCII = new TextEncoder();
+var ANCHOR_ID_PREFIX = "mobi-toc-";
+function isWithinTag(raw, offset) {
+  const open = raw.lastIndexOf("<", offset - 1);
+  if (open === -1) return false;
+  const close = raw.indexOf(">", open);
+  return close === -1 || close >= offset;
+}
+function openTagInsertionPoint(raw, offset) {
+  const first = raw.charCodeAt(offset + 1);
+  const isLetter = first >= 65 && first <= 90 || first >= 97 && first <= 122;
+  if (!isLetter) return -1;
+  for (let i = offset + 2; i < raw.length; i++) {
+    const code = raw.charCodeAt(i);
+    if (code === 32 || code === 9 || code === 10 || code === 13 || code === 47 || code === 62) {
+      return i;
+    }
+  }
+  return -1;
+}
+function landingAt(raw, offset) {
+  const miss = (kind) => ({ kind, insertionPoint: -1 });
+  if (!Number.isInteger(offset) || offset <= 0 || offset >= raw.length) return miss("out-of-range");
+  if (isWithinTag(raw, offset)) return miss("inside-tag");
+  if (raw[offset] !== "<") return miss("in-text");
+  const insertionPoint = openTagInsertionPoint(raw, offset);
+  return insertionPoint === -1 ? miss("not-open-tag") : { kind: "open-tag", insertionPoint };
+}
+function injectAnchors(bytes, offsets) {
+  const raw = LATIN1.decode(bytes);
+  const targets = [...new Set(offsets)].sort((a, b) => a - b);
+  const placements = [];
+  const edits = [];
+  const pieces = [];
+  let cursor = 0;
+  for (const at of targets) {
+    const landing = landingAt(raw, at);
+    if (landing.kind !== "open-tag") {
+      placements.push({ at, kind: landing.kind });
+      continue;
+    }
+    const id = `${ANCHOR_ID_PREFIX}${String(at)}`;
+    const insertion = ASCII.encode(` id="${id}"`);
+    pieces.push(bytes.subarray(cursor, landing.insertionPoint), insertion);
+    edits.push({ at: landing.insertionPoint, inserted: insertion.byteLength });
+    placements.push({ at, kind: "open-tag", id });
+    cursor = landing.insertionPoint;
+  }
+  if (edits.length === 0) return { bytes, edits, placements };
+  pieces.push(bytes.subarray(cursor));
+  const total = pieces.reduce((sum, piece) => sum + piece.byteLength, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const piece of pieces) {
+    out.set(piece, offset);
+    offset += piece.byteLength;
+  }
+  return { bytes: out, edits, placements };
+}
+
+// src/formats/mobi/label.ts
+function sourceSuffix(label) {
+  return label === void 0 ? "" : `\uFF08\u6E90 ${label}\uFF09`;
+}
+
+// src/formats/mobi/header.ts
+var PALMDOC_HEADER_BYTES = 16;
+var EXTH_MAGIC = "EXTH";
+var MOBI6_FILE_VERSION = 6;
+var KF8_FILE_VERSION = 8;
+var UTF8_CODEPAGE = 65001;
+var MOBI_MAGIC = "MOBI";
+var EXTH_BLOCK_HEADER_BYTES = 12;
+var EXTH_ENTRY_HEADER_BYTES = 8;
+var AT = {
+  headerLength: 20,
+  codepage: 28,
+  fileVersion: 36,
+  fullNameOffset: 84,
+  fullNameLength: 88,
+  firstResourceRecord: 108,
+  huffOffset: 112,
+  huffCount: 116,
+  fdstOffset: 192,
+  fdstFlowCount: 196,
+  ncxIndex: 244,
+  fragmentIndex: 248
+};
+var MIN_KF8_HEADER_BYTES = AT.fdstFlowCount + 4;
+var NO_INDEX = 4294967295;
+var MIN_INDEX_HEADER_BYTES = AT.ncxIndex + 4 - PALMDOC_HEADER_BYTES;
+var MIN_FRAGMENT_HEADER_BYTES = AT.fragmentIndex + 4 - PALMDOC_HEADER_BYTES;
+var MIN_MOBI_HEADER_BYTES = AT.huffCount + 4;
+function readIndexes(view, headerLength, fileVersion) {
+  if (headerLength < MIN_INDEX_HEADER_BYTES) return {};
+  const ncxIndex = view.getUint32(AT.ncxIndex, false);
+  const indexes = ncxIndex === NO_INDEX ? {} : { ncxIndex };
+  if (fileVersion !== KF8_FILE_VERSION) return indexes;
+  if (headerLength < MIN_FRAGMENT_HEADER_BYTES) return indexes;
+  const fragmentIndex = view.getUint32(AT.fragmentIndex, false);
+  return fragmentIndex === NO_INDEX ? indexes : { ...indexes, fragmentIndex };
+}
+function decoderFor(codepage) {
+  return new TextDecoder(codepage === UTF8_CODEPAGE ? "utf-8" : "windows-1252", {
+    ignoreBOM: true
+  });
+}
+function record0(palmdb, label) {
+  if (palmdb.recordCount < 1) {
+    throw new FormatError(`MOBI \u7F3A\u5C11\u8BB0\u5F55 0\uFF08\u5934\u8BB0\u5F55\uFF09\uFF1A\u5BB9\u5668\u91CC\u4E00\u6761\u8BB0\u5F55\u90FD\u6CA1\u6709${sourceSuffix(label)}`);
+  }
+  const bytes = palmdb.record(0);
+  if (bytes.byteLength < PALMDOC_HEADER_BYTES) {
+    throw new FormatError(
+      `MOBI \u8BB0\u5F55 0 \u4E0D\u8DB3 ${String(PALMDOC_HEADER_BYTES)} \u5B57\u8282\uFF08PalmDOC \u5934\uFF09\uFF1A\u5B9E\u9645 ${String(bytes.byteLength)} \u5B57\u8282${sourceSuffix(label)}`
+    );
+  }
+  return bytes;
+}
+function asciiAt(bytes, at, length) {
+  return String.fromCharCode(...bytes.subarray(at, at + length));
+}
+function parsePalmDocHeader(palmdb, label) {
+  const bytes = record0(palmdb, label);
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  return {
+    compression: view.getUint16(0, false),
+    textLength: view.getUint32(4, false),
+    textRecordCount: view.getUint16(8, false),
+    maxSectionSize: view.getUint16(10, false)
+  };
+}
+function parseExth(record, exthAt, label) {
+  const table = /* @__PURE__ */ new Map();
+  if (exthAt + EXTH_BLOCK_HEADER_BYTES > record.byteLength) return table;
+  if (asciiAt(record, exthAt, EXTH_MAGIC.length) !== EXTH_MAGIC) return table;
+  const view = new DataView(record.buffer, record.byteOffset, record.byteLength);
+  const declared = view.getUint32(exthAt + 4, false);
+  const end = exthAt + declared;
+  if (end > record.byteLength) {
+    throw new FormatError(
+      `EXTH \u5757\u957F\u5EA6\u8D8A\u754C\uFF1A\u81EA\u8FF0 ${String(declared)} \u5B57\u8282\uFF08\u5230 ${String(end)}\uFF09\uFF0C\u4F46\u8BB0\u5F55 0 \u53EA\u6709 ${String(record.byteLength)} \u5B57\u8282${sourceSuffix(label)}`
+    );
+  }
+  let cursor = exthAt + EXTH_BLOCK_HEADER_BYTES;
+  while (cursor + EXTH_ENTRY_HEADER_BYTES <= end) {
+    const type = view.getUint32(cursor, false);
+    const length = view.getUint32(cursor + 4, false);
+    if (length < EXTH_ENTRY_HEADER_BYTES) {
+      throw new FormatError(
+        `EXTH \u6761\u76EE\u957F\u5EA6\u975E\u6CD5\uFF1Atype ${String(type)} \u81EA\u8FF0 ${String(length)} \u5B57\u8282\uFF0C\u5C0F\u4E8E\u6761\u76EE\u5934\u81EA\u8EAB\u7684 ${String(EXTH_ENTRY_HEADER_BYTES)} \u5B57\u8282${sourceSuffix(label)}`
+      );
+    }
+    if (cursor + length > end) {
+      throw new FormatError(
+        `EXTH \u6761\u76EE\u8D8A\u51FA\u5757\u5C3E\uFF1Atype ${String(type)} \u5230 ${String(cursor + length)}\uFF0C\u5757\u5C3E\u5728 ${String(end)}${sourceSuffix(label)}`
+      );
+    }
+    const data = record.subarray(cursor + EXTH_ENTRY_HEADER_BYTES, cursor + length);
+    const list = table.get(type);
+    if (list === void 0) {
+      table.set(type, [data]);
+    } else {
+      list.push(data);
+    }
+    cursor += length;
+  }
+  return table;
+}
+function parseMobiHeader(palmdb, label) {
+  const bytes = record0(palmdb, label);
+  const magic = asciiAt(bytes, PALMDOC_HEADER_BYTES, MOBI_MAGIC.length);
+  if (magic !== MOBI_MAGIC) {
+    throw new FormatError(
+      `MOBI \u5934\u9B54\u6570\u4E0D\u7B26\uFF1A\u671F\u671B "${MOBI_MAGIC}"\uFF0C\u8BFB\u5230 "${magic}"${sourceSuffix(label)}`
+    );
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const headerLength = view.getUint32(AT.headerLength, false);
+  const exthAt = PALMDOC_HEADER_BYTES + headerLength;
+  if (headerLength < EXTH_ENTRY_HEADER_BYTES || exthAt > bytes.byteLength) {
+    throw new FormatError(
+      `MOBI \u5934\u957F\u5EA6\u975E\u6CD5\uFF1AheaderLength = ${String(headerLength)}\uFF08EXTH \u8D77\u70B9 ${String(exthAt)}\uFF09\uFF0C\u8BB0\u5F55 0 \u53EA\u6709 ${String(bytes.byteLength)} \u5B57\u8282${sourceSuffix(label)}`
+    );
+  }
+  if (bytes.byteLength < PALMDOC_HEADER_BYTES + MIN_MOBI_HEADER_BYTES) {
+    throw new FormatError(
+      `MOBI \u5934\u8FC7\u77ED\uFF1A\u8BB0\u5F55 0 \u53EA\u6709 ${String(bytes.byteLength)} \u5B57\u8282\uFF0C\u800C 0x${MIN_MOBI_HEADER_BYTES.toString(16)} \u4E4B\u524D\u7684\u5B57\u6BB5\u9700\u8981 ${String(PALMDOC_HEADER_BYTES + MIN_MOBI_HEADER_BYTES)} \u5B57\u8282${sourceSuffix(label)}`
+    );
+  }
+  const fileVersion = view.getUint32(AT.fileVersion, false);
+  if (fileVersion !== MOBI6_FILE_VERSION && fileVersion !== KF8_FILE_VERSION) {
+    throw new FormatError(
+      `MOBI \u6587\u4EF6\u7248\u672C ${String(fileVersion)} \u4E0D\u53D7\u652F\u6301\uFF1A\u53EA\u652F\u6301 MOBI6\uFF08${String(MOBI6_FILE_VERSION)}\uFF09\u4E0E KF8 / AZW3\uFF08${String(KF8_FILE_VERSION)}\uFF09${sourceSuffix(label)}`
+    );
+  }
+  return {
+    headerLength,
+    fileVersion,
+    codepage: view.getUint32(AT.codepage, false),
+    firstResourceRecord: view.getUint32(AT.firstResourceRecord, false),
+    fullNameOffset: view.getUint32(AT.fullNameOffset, false),
+    fullNameLength: view.getUint32(AT.fullNameLength, false),
+    huff: {
+      offset: view.getUint32(AT.huffOffset, false),
+      count: view.getUint32(AT.huffCount, false)
+    },
+    // ⚠️ **只在 KF8 上读**：MOBI6 的同一偏移是 `first_content` / `last_content`（事实 3），
+    // 按 `u32` 读会得到越界的巨大数（实测 65746）。「没有」用 `undefined` 表达，
+    // 而不是读出一个 0 再让调用方去猜。
+    ...fileVersion === KF8_FILE_VERSION ? { fdst: readFdst(view, headerLength, label) } : {},
+    // 索引表位置（③b）。`ncx_index` 两个版本都读；`fragment_index` 仅 KF8（见 `readIndexes`）。
+    ...readIndexes(view, headerLength, fileVersion),
+    exth: parseExth(bytes, exthAt, label)
+  };
+}
+function readFdst(view, headerLength, label) {
+  if (headerLength < MIN_KF8_HEADER_BYTES) {
+    throw new FormatError(
+      `KF8 \u5934\u957F\u5EA6\u4E0D\u8DB3\uFF1AheaderLength = ${String(headerLength)}\uFF0C\u8BFB fdst \u5B57\u6BB5\u9700\u8981\u81F3\u5C11 ${String(MIN_KF8_HEADER_BYTES)} \u5B57\u8282${sourceSuffix(label)}`
+    );
+  }
+  return {
+    offset: view.getUint32(AT.fdstOffset, false),
+    flowCount: view.getUint32(AT.fdstFlowCount, false)
+  };
+}
+function exthTexts(exth, type, codepage) {
+  const decoder = decoderFor(codepage);
+  return (exth.get(type) ?? []).map((value) => decoder.decode(value));
+}
+
+// src/formats/mobi/kf8.ts
+var FDST_MAGIC = "FDST";
+var FDST_COUNT_AT = 8;
+var FDST_SPAN_BYTES = 8;
+var XML_DECL = [60, 63, 120, 109, 108];
+var HTML_CLOSE = [60, 47, 104, 116, 109, 108, 62];
+var LATIN12 = new TextDecoder("latin1");
+var AID_TAG = /<([a-zA-Z][\w:-]*)\b[^>]*\said\s*=\s*["'][^"']*["'][^>]*>/g;
+var KINDLE_URI = /kindle:(flow|embed):([0-9A-Za-z]+)(?:\?mime=([^"')\s>]+))?/g;
+function base32(text) {
+  if (text === void 0 || text.length === 0 || text.length > 7) return void 0;
+  let value = 0;
+  for (const char of text) {
+    const code = char.charCodeAt(0);
+    const digit = code >= 48 && code <= 57 ? code - 48 : code >= 65 && code <= 86 ? code - 65 + 10 : -1;
+    if (digit < 0) return void 0;
+    value = value * 32 + digit;
+  }
+  return value;
+}
+function indexOfBytes(haystack, needle, from = 0) {
+  const limit = haystack.byteLength - needle.length;
+  outer: for (let at = Math.max(from, 0); at <= limit; at += 1) {
+    for (let offset = 0; offset < needle.length; offset += 1) {
+      if (haystack[at + offset] !== needle[offset]) continue outer;
+    }
+    return at;
+  }
+  return -1;
+}
+function insertPoint(skeleton) {
+  const text = LATIN12.decode(skeleton);
+  let last = -1;
+  for (const match of text.matchAll(AID_TAG)) {
+    if (match[0].endsWith("/>")) continue;
+    last = match.index + match[0].length;
+  }
+  return last;
+}
+function asciiBytes(text) {
+  const out = new Uint8Array(text.length);
+  for (let index = 0; index < text.length; index += 1) {
+    out[index] = text.charCodeAt(index) & 255;
+  }
+  return out;
+}
+function parseFlows(palmdb, header, textLength, label) {
+  const where = sourceSuffix(label);
+  const at = header.fdst;
+  if (at === void 0) {
+    throw new FormatError(`\u8FD9\u672C\u4E66\u6CA1\u6709 FDST \u8868\uFF1A\`fdst\` \u53EA\u5728 KF8\uFF08fileVersion = 8\uFF09\u4E0A\u5B58\u5728${where}`);
+  }
+  if (at.offset < 1 || at.offset >= palmdb.recordCount) {
+    throw new FormatError(
+      `FDST \u8BB0\u5F55\u53F7\u8D8A\u754C\uFF1A${String(at.offset)}\uFF0C\u5BB9\u5668\u53EA\u6709 ${String(palmdb.recordCount)} \u6761\u8BB0\u5F55${where}`
+    );
+  }
+  const record = palmdb.record(at.offset);
+  if (indexOfBytes(record, [70, 68, 83, 84]) !== 0) {
+    throw new FormatError(`FDST \u9B54\u6570\u4E0D\u7B26\uFF1A\u8BB0\u5F55 ${String(at.offset)} \u4E0D\u662F "${FDST_MAGIC}"${where}`);
+  }
+  const needed = FDST_COUNT_AT + 4;
+  if (record.byteLength < needed) {
+    throw new FormatError(
+      `FDST \u8BB0\u5F55\u592A\u77ED\uFF1A\u53EA\u6709 ${String(record.byteLength)} \u5B57\u8282\uFF0C\u8FDE\u6BB5\u6570\u5B57\u6BB5\uFF08\u5230 ${String(needed)}\uFF09\u90FD\u653E\u4E0D\u4E0B${where}`
+    );
+  }
+  const view = new DataView(record.buffer, record.byteOffset, record.byteLength);
+  const count = view.getUint32(FDST_COUNT_AT, false);
+  if (count !== at.flowCount) {
+    throw new FormatError(
+      `FDST \u6BB5\u6570\u4E0D\u7B26\uFF1A\u5934\u81EA\u8FF0 ${String(at.flowCount)}\uFF0C\u8868\u91CC\u662F ${String(count)}${where}`
+    );
+  }
+  if (count === 0) {
+    throw new FormatError(`FDST \u6BB5\u6570\u4E3A 0\uFF1A\u6B63\u6587\u4E0D\u53EF\u80FD\u6CA1\u6709\u6BB5${where}`);
+  }
+  const tableEnd = needed + count * FDST_SPAN_BYTES;
+  if (record.byteLength < tableEnd) {
+    throw new FormatError(
+      `FDST \u8868\u88AB\u622A\u65AD\uFF1A${String(count)} \u6BB5\u9700\u8981 ${String(tableEnd)} \u5B57\u8282\uFF0C\u8BB0\u5F55\u53EA\u6709 ${String(record.byteLength)} \u5B57\u8282${where}`
+    );
+  }
+  const spans = [];
+  let expected = 0;
+  for (let index = 0; index < count; index += 1) {
+    const at2 = needed + index * FDST_SPAN_BYTES;
+    const start = view.getUint32(at2, false);
+    const end = view.getUint32(at2 + 4, false);
+    if (start !== expected) {
+      throw new FormatError(
+        `FDST \u7B2C ${String(index)} \u6BB5\u4E0D\u4ECE ${String(expected)} \u5F00\u59CB\uFF08\u8BFB\u5230 ${String(start)}\uFF09\uFF1A\u5404\u6BB5\u5FC5\u987B\u8FDE\u7EED\u8986\u76D6 [0, textLength)${where}`
+      );
+    }
+    if (end <= start) {
+      throw new FormatError(
+        `FDST \u7B2C ${String(index)} \u6BB5\u4E3A\u7A7A\u6216\u5012\u5E8F\uFF1A[${String(start)}, ${String(end)})${where}`
+      );
+    }
+    spans.push({ start, end });
+    expected = end;
+  }
+  if (expected !== textLength) {
+    throw new FormatError(
+      `FDST \u672B\u6BB5\u7ED3\u675F\u4E8E ${String(expected)}\uFF0C\u4E0E textLength = ${String(textLength)} \u4E0D\u7B26${where}`
+    );
+  }
+  return spans;
+}
+function splitKf8Documents(flow0, label) {
+  const where = sourceSuffix(label);
+  const starts = [];
+  for (let at = indexOfBytes(flow0, XML_DECL); at !== -1; at = indexOfBytes(flow0, XML_DECL, at + 1)) {
+    starts.push(at);
+  }
+  if (starts.length === 0) {
+    throw new FormatError(`KF8 \u6B63\u6587\u91CC\u627E\u4E0D\u5230\u4EFB\u4F55 \`<?xml\`\uFF0C\u65E0\u6CD5\u5207\u5206\u6587\u6863${where}`);
+  }
+  const documents = [];
+  for (const [index, skelStart] of starts.entries()) {
+    const htmlAt = indexOfBytes(flow0, HTML_CLOSE, skelStart);
+    if (htmlAt === -1) {
+      throw new FormatError(`KF8 \u7B2C ${String(index)} \u4E2A skeleton \u6CA1\u6709 \`</html>\`${where}`);
+    }
+    const skelEnd = htmlAt + HTML_CLOSE.length;
+    const skeleton = flow0.subarray(skelStart, skelEnd);
+    const at = insertPoint(skeleton);
+    if (at < 0) {
+      throw new FormatError(
+        `KF8 \u7B2C ${String(index)} \u4E2A skeleton \u91CC\u6CA1\u6709\u5E26 \`aid\` \u7684\u975E\u81EA\u95ED\u5408\u6807\u7B7E\uFF0C\u63D2\u5165\u70B9\u4E0D\u6210\u7ACB${where}`
+      );
+    }
+    const fragment = flow0.subarray(skelEnd, starts[index + 1] ?? flow0.byteLength);
+    const merged = new Uint8Array(skeleton.byteLength + fragment.byteLength);
+    merged.set(skeleton.subarray(0, at), 0);
+    merged.set(fragment, at);
+    merged.set(skeleton.subarray(at), at + fragment.byteLength);
+    documents.push(merged);
+  }
+  return documents;
+}
+function rewriteKindleUris(bytes, resolve, label) {
+  const where = sourceSuffix(label);
+  const text = LATIN12.decode(bytes);
+  const pieces = [];
+  let cursor = 0;
+  for (const match of text.matchAll(KINDLE_URI)) {
+    const [whole, kind, digits, mime] = match;
+    const index = base32(digits);
+    if (index === void 0) {
+      throw new FormatError(
+        `KF8 \u79C1\u6709 URI \u7684\u7F16\u53F7\u4E0D\u662F\u5408\u6CD5\u57FA 32\uFF1A"${String(digits)}"\uFF08\u5B57\u7B26\u96C6\u662F 0-9 \u4E0E A-V\uFF09${where}`
+      );
+    }
+    pieces.push(bytes.subarray(cursor, match.index));
+    pieces.push(asciiBytes(resolve(kind, index, mime)));
+    cursor = match.index + whole.length;
+  }
+  if (pieces.length === 0) return bytes;
+  pieces.push(bytes.subarray(cursor));
+  const total = pieces.reduce((sum, piece) => sum + piece.byteLength, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const piece of pieces) {
+    out.set(piece, offset);
+    offset += piece.byteLength;
+  }
+  return out;
+}
+
+// src/formats/mobi/indx.ts
+var INDX_MAGIC = 1229866072;
+var TAGX_MAGIC = 1413564248;
+var ORDT_HACK_CODE = 65002;
+var ORDT_COUNT_AT = 164;
+var IDXT_MARKER_BYTES = 4;
+var IDXT_SLOT_BYTES = 2;
+function u32At(bytes, at) {
+  return ((bytes[at] ?? 0) << 24 | (bytes[at + 1] ?? 0) << 16 | (bytes[at + 2] ?? 0) << 8 | (bytes[at + 3] ?? 0)) >>> 0;
+}
+function u16At(bytes, at) {
+  return ((bytes[at] ?? 0) << 8 | (bytes[at + 1] ?? 0)) >>> 0;
+}
+function parseIndxHeader(bytes, label) {
+  if (u32At(bytes, 0) !== INDX_MAGIC) return null;
+  const code = u32At(bytes, 28);
+  if (code === ORDT_HACK_CODE || u32At(bytes, ORDT_COUNT_AT) !== 0 || u32At(bytes, ORDT_COUNT_AT + 4) > 0) {
+    throw new FormatError(
+      `\u89E6\u53D1\u4E86\u672C\u6279\u4E0D\u652F\u6301\u7684 ORDT / ESP \u7D22\u5F15\u5206\u652F\uFF08code=0x${code.toString(16)}\uFF09\u2014\u2014 \u8BE5\u4E66\u7684\u76EE\u5F55\u6587\u672C\u8981\u4E24\u5F20 ORDT \u8868\u624D\u80FD\u89E3\u5BF9\uFF0C\u672C\u5305\u4F1A\u89E3\u51FA\u9519\u503C\uFF0C\u6545\u76F4\u63A5\u62A5\u9519${sourceSuffix(label)}`
+    );
+  }
+  return {
+    len: u32At(bytes, 4),
+    start: u32At(bytes, 20),
+    count: u32At(bytes, 24),
+    nctoc: u32At(bytes, 52)
+  };
+}
+function readTagSection(bytes, at, label) {
+  if (u32At(bytes, at) !== TAGX_MAGIC) return null;
+  const firstEntryOffset = u32At(bytes, at + 4);
+  if (at + firstEntryOffset > bytes.length) {
+    throw new FormatError(
+      `TAGX \u7684 firstEntryOffset=${String(firstEntryOffset)} \u8D8A\u51FA\u8BB0\u5F55\uFF08TAGX \u5728 ${String(at)}\uFF0C\u8BB0\u5F55\u5171 ${String(bytes.length)} \u5B57\u8282\uFF09${sourceSuffix(label)}`
+    );
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const tags = [];
+  for (let i = 12; i < firstEntryOffset; i += 4) {
+    tags.push({
+      tag: view.getUint8(at + i),
+      valuesPerEntry: view.getUint8(at + i + 1),
+      mask: view.getUint8(at + i + 2),
+      endFlag: view.getUint8(at + i + 3)
+    });
+  }
+  return { controlByteCount: u32At(bytes, at + 8), tags };
+}
+function countSetBits(value) {
+  let count = 0;
+  let rest = value;
+  while (rest !== 0) {
+    if ((rest & 1) === 1) count += 1;
+    rest >>= 1;
+  }
+  return count;
+}
+function readTagMap(controlByteCount, specs, data, from, to, label) {
+  const found = [];
+  let controlByteIndex = 0;
+  let valuesAt = from + controlByteCount;
+  for (const { tag, valuesPerEntry, mask: rawMask, endFlag } of specs) {
+    if (endFlag === 1) {
+      controlByteIndex += 1;
+      continue;
+    }
+    let mask = rawMask;
+    let value = (data[from + controlByteIndex] ?? 0) & mask;
+    if (value === 0) continue;
+    if (value === mask) {
+      if (countSetBits(mask) > 1) {
+        const [consumed, byteCount] = readVariableWidthInt(data, valuesAt, label);
+        valuesAt += consumed;
+        found.push({ tag, valueCount: null, valueBytes: byteCount, valuesPerEntry });
+      } else {
+        found.push({ tag, valueCount: 1, valueBytes: 0, valuesPerEntry });
+      }
+    } else {
+      while ((mask & 1) === 0) {
+        mask >>= 1;
+        value >>= 1;
+      }
+      found.push({ tag, valueCount: value, valueBytes: 0, valuesPerEntry });
+    }
+  }
+  const tags = /* @__PURE__ */ new Map();
+  for (const { tag, valueCount, valueBytes, valuesPerEntry } of found) {
+    const values = [];
+    if (valueCount === null) {
+      let consumedBytes = 0;
+      while (consumedBytes < valueBytes) {
+        const [consumed, value] = readVariableWidthInt(data, valuesAt, label);
+        valuesAt += consumed;
+        consumedBytes += consumed;
+        values.push(value);
+      }
+    } else {
+      for (let i = 0; i < valueCount * valuesPerEntry; i += 1) {
+        const [consumed, value] = readVariableWidthInt(data, valuesAt, label);
+        valuesAt += consumed;
+        values.push(value);
+      }
+    }
+    tags.set(tag, values);
+  }
+  let leftover = 0;
+  for (let i = valuesAt; i < to; i += 1) if (data[i] !== 0) leftover += 1;
+  return { tags, leftover };
+}
+function readCtoc(bytes, label) {
+  const text = /* @__PURE__ */ new Map();
+  let at = 0;
+  while (at < bytes.length && bytes[at] !== 0) {
+    const [consumed, length] = readVariableWidthInt(bytes, at, label);
+    const from = at + consumed;
+    const to = from + length;
+    if (to > bytes.length) {
+      throw new FormatError(
+        `CTOC \u6587\u672C\u8D8A\u754C\uFF1A\u504F\u79FB ${String(at)} \u5904\u58F0\u660E\u957F\u5EA6 ${String(length)}\uFF0C\u4F46\u4ECE ${String(from)} \u8D77\u53EA\u5269 ${String(bytes.length - from)} \u5B57\u8282${sourceSuffix(label)}`
+      );
+    }
+    text.set(at, bytes.subarray(from, to));
+    at = to;
+  }
+  return text;
+}
+function loadRecord(palmdb, index, what, label) {
+  if (index < 0 || index >= palmdb.recordCount) {
+    throw new FormatError(
+      `${what}\u7684\u8BB0\u5F55\u53F7 ${String(index)} \u8D8A\u754C\uFF08\u5171 ${String(palmdb.recordCount)} \u6761\u8BB0\u5F55\uFF09${sourceSuffix(label)}`
+    );
+  }
+  return palmdb.record(index);
+}
+function readVariableWidthInt(data, at, label) {
+  let value = 0;
+  let consumed = 0;
+  for (; ; ) {
+    const byte = data[at + consumed];
+    if (byte === void 0) {
+      throw new FormatError(
+        `\u53D8\u5BBD\u503C\u5728 ${String(at + consumed)} \u5904\u8D8A\u754C\uFF1A\u8BFB\u6EE1 ${String(consumed)} \u5B57\u8282\u4ECD\u672A\u89C1\u7ED3\u675F\u6807\u5FD7\uFF08\u53D8\u5BBD\u503C\u7684**\u9AD8\u4F4D**\u662F\u7ED3\u675F\u6807\u5FD7\uFF09${sourceSuffix(label)}`
+      );
+    }
+    consumed += 1;
+    value = value * 128 + (byte & 127);
+    if ((byte & 128) !== 0) return [consumed, value];
+  }
+}
+function parseIndx(palmdb, at, label) {
+  const head = loadRecord(palmdb, at, "INDX \u5934", label);
+  const header = parseIndxHeader(head, label);
+  if (header === null) {
+    throw new FormatError(`\u8BB0\u5F55 ${String(at)} \u4E0D\u662F INDX\uFF08\u9B54\u6570\u4E0D\u7B26\uFF09${sourceSuffix(label)}`);
+  }
+  const tagSection = readTagSection(head, header.len, label);
+  if (tagSection === null) {
+    throw new FormatError(
+      `\u8BB0\u5F55 ${String(at)} \u7684 INDX \u5934\u91CC\u6CA1\u6709 TAGX \u6807\u7B7E\u8868\uFF08\u504F\u79FB ${String(header.len)}\uFF09${sourceSuffix(label)}`
+    );
+  }
+  const ctoc = /* @__PURE__ */ new Map();
+  for (let j = 0; j < header.nctoc; j += 1) {
+    const block = loadRecord(palmdb, at + header.count + 1 + j, "CTOC \u6587\u672C\u6BB5", label);
+    for (const [key, value] of readCtoc(block, label)) ctoc.set(key + j * 65536, value);
+  }
+  const entries = [];
+  let leftover = 0;
+  for (let i = 1; i <= header.count; i += 1) {
+    const data = loadRecord(palmdb, at + i, "INDX \u6570\u636E\u6BB5", label);
+    const sub = parseIndxHeader(data, label);
+    if (sub === null) {
+      throw new FormatError(
+        `\u8BB0\u5F55 ${String(at + i)} \u4E0D\u662F INDX \u6570\u636E\u6BB5\uFF08\u9B54\u6570\u4E0D\u7B26\uFF09${sourceSuffix(label)}`
+      );
+    }
+    const bounds = [];
+    let cursor;
+    const maxSlots = Math.floor(data.byteLength / IDXT_SLOT_BYTES);
+    const slots = Math.min(sub.count, maxSlots);
+    for (let j = 0; j < slots; j += 1) {
+      const from = u16At(data, sub.start + IDXT_MARKER_BYTES + IDXT_SLOT_BYTES * j);
+      if (cursor !== void 0) bounds.push([cursor, from]);
+      cursor = from;
+    }
+    if (cursor !== void 0) bounds.push([cursor, sub.start]);
+    for (const [startPos, endPos] of bounds) {
+      const textLength = data[startPos] ?? 0;
+      const text = data.subarray(startPos + 1, startPos + 1 + textLength);
+      const parsed = readTagMap(
+        tagSection.controlByteCount,
+        tagSection.tags,
+        data,
+        startPos + 1 + textLength,
+        endPos,
+        label
+      );
+      leftover += parsed.leftover;
+      entries.push({ text, tags: parsed.tags });
+    }
+  }
+  return { count: header.count, nctoc: header.nctoc, entries, ctoc, leftover };
+}
+
+// src/formats/mobi/kf8toc.ts
+var LATIN13 = new TextDecoder("latin1");
+var XML_DECL_TEXT = "<?xml";
+var TAG_PATTERN = /<[^>]*>/g;
+var ANCHOR_PATTERN = /\s(?:id|name)\s*=\s*["']([^"']*)["']/i;
+var NCX_NOFFS = 3;
+var NCX_HLVL = 4;
+var NCX_POS_FID = 6;
+var NCX_CHILD1 = 22;
+var NCX_CHILDN = 23;
+var FRAG_CHAPTER = 3;
+function scanChapterStarts(flow0) {
+  const text = LATIN13.decode(flow0);
+  const starts = [];
+  for (let at = text.indexOf(XML_DECL_TEXT); at !== -1; at = text.indexOf(XML_DECL_TEXT, at + 1)) {
+    starts.push(at);
+  }
+  return starts;
+}
+function backSearchId(part, q) {
+  if (q < 0 || q > part.length) return void 0;
+  const text = LATIN13.decode(part);
+  const gt = text.indexOf(">", q);
+  const lt = text.indexOf("<", q);
+  let at = q;
+  if (lt === q || gt !== -1 && gt < lt) at = gt + 1;
+  const tags = [...text.slice(0, at).matchAll(TAG_PATTERN)];
+  for (const match of tags.reverse()) {
+    const tag = match[0];
+    if (tag.startsWith("<body ")) return void 0;
+    if (tag.startsWith("<meta ")) continue;
+    const named = ANCHOR_PATTERN.exec(tag);
+    if (named !== null && named[1] !== "") return named[1];
+  }
+  return void 0;
+}
+function readFragments(table) {
+  return table.entries.map((entry) => ({
+    insertpos: Number(LATIN13.decode(entry.text)),
+    chapter: entry.tags.get(FRAG_CHAPTER)?.[0] ?? 0
+  }));
+}
+function readNcxRow(entry, ncx, fragments, documents, starts, decodeLabel2, where) {
+  const level = entry.tags.get(NCX_HLVL)?.[0] ?? -1;
+  const child1 = entry.tags.get(NCX_CHILD1)?.[0] ?? -1;
+  const childn = entry.tags.get(NCX_CHILDN)?.[0] ?? -1;
+  const noffs = entry.tags.get(NCX_NOFFS)?.[0];
+  const fid = entry.tags.get(NCX_POS_FID)?.[0] ?? -1;
+  const off = entry.tags.get(NCX_POS_FID)?.[1] ?? 0;
+  const fragmentRow = fragments[fid];
+  if (fragmentRow === void 0) {
+    throw new FormatError(
+      `KF8 \u7684\u76EE\u5F55\u9879\u6307\u5411\u7247\u6BB5 ${String(fid)}\uFF0C\u4F46\u7247\u6BB5\u8868\u53EA\u6709 ${String(fragments.length)} \u6761${where}`
+    );
+  }
+  const chapter = fragmentRow.chapter;
+  const document = documents[chapter];
+  const start = starts[chapter];
+  if (document === void 0 || start === void 0) {
+    throw new FormatError(
+      `KF8 \u7684\u76EE\u5F55\u9879\u843D\u5728\u7AE0 ${String(chapter)}\uFF0C\u4F46\u53EA\u6709 ${String(documents.length)} \u7AE0${where}`
+    );
+  }
+  const label = decodeLabel2(ncx.ctoc.get(noffs ?? -1) ?? new Uint8Array(0));
+  return {
+    label,
+    level,
+    child1,
+    childn,
+    // ⚠️ 这个名字必须与 `open.ts::openKf8` 产出的章节名**逐字一致**，否则目录跳转落空。
+    href: `text/${String(chapter).padStart(4, "0")}.xhtml`,
+    fragment: backSearchId(document, fragmentRow.insertpos + off - start)
+  };
+}
+function buildLevel(rows, start, end, level) {
+  const from = start <= 0 ? 0 : start;
+  const to = end <= 0 ? rows.length : end;
+  const items = [];
+  for (let i = from; i < to; i += 1) {
+    const row = rows[i];
+    if (row === void 0 || row.level !== level) continue;
+    items.push({
+      label: row.label,
+      href: row.href,
+      ...row.fragment === void 0 ? {} : { fragment: row.fragment },
+      children: row.child1 >= 0 ? buildLevel(rows, row.child1, row.childn + 1, level + 1) : []
+    });
+  }
+  return items;
+}
+function countItems(items) {
+  let count = 0;
+  for (const item of items) count += 1 + countItems(item.children);
+  return count;
+}
+function parseKf8Toc(palmdb, header, flow0, documents, label) {
+  const where = sourceSuffix(label);
+  const { ncxIndex, fragmentIndex } = header;
+  if (ncxIndex === void 0) {
+    return [];
+  }
+  if (fragmentIndex === void 0) {
+    throw new FormatError(
+      `KF8 \u7684\u5934\u91CC\u6709 NCX \u7D22\u5F15\u8868\u5374\u6CA1\u6709\u7247\u6BB5\u8868\uFF08\`fragment_index\`\uFF09\u21D2 \u76EE\u5F55\u76EE\u6807\u65E0\u6CD5\u5B9A\u4F4D${where}`
+    );
+  }
+  const ncx = parseIndx(palmdb, ncxIndex, label);
+  const fragments = readFragments(parseIndx(palmdb, fragmentIndex, label));
+  const starts = scanChapterStarts(flow0);
+  if (starts.length !== documents.length) {
+    throw new FormatError(
+      `KF8 \u7684\u7AE0\u8282\u8D77\u70B9\u6570\uFF08${String(starts.length)}\uFF09\u4E0E\u5DF2\u5207\u5206\u7684\u6587\u6863\u6570\uFF08${String(documents.length)}\uFF09\u4E0D\u4E00\u81F4 \u2014\u2014 \u4E24\u4E2A\u6765\u6E90\u5DF2\u7ECF\u5206\u53C9${where}`
+    );
+  }
+  const decoder = decoderFor(header.codepage);
+  const decodeLabel2 = (bytes) => decoder.decode(bytes);
+  const rows = ncx.entries.map(
+    (entry) => readNcxRow(entry, ncx, fragments, documents, starts, decodeLabel2, where)
+  );
+  const toc = buildLevel(rows, -1, -1, 0);
+  const emitted = countItems(toc);
+  if (emitted !== rows.length) {
+    throw new FormatError(
+      `KF8 \u7684\u76EE\u5F55\u5C42\u7EA7\u6811\u53EA\u8986\u76D6\u4E86 ${String(emitted)} / ${String(rows.length)} \u4E2A\u6761\u76EE \u2014\u2014 \`hlvl\` \u4E0D\u8FDE\u7EED\u6216 \`child1\`/\`childn\` \u81EA\u76F8\u77DB\u76FE\u65F6\u4F1A\u9759\u9ED8\u5C11\u7ED9\u76EE\u5F55${where}`
+    );
+  }
+  return toc;
+}
+
+// src/formats/mobi/palmdb.ts
+var HEADER_BYTES = 78;
+var RECORD_ENTRY_BYTES = 8;
+var NUM_RECORDS_AT = 76;
+function parsePalmDb(bytes, label) {
+  const where = sourceSuffix(label);
+  if (bytes.byteLength < HEADER_BYTES) {
+    throw new FormatError(
+      `PalmDB \u5BB9\u5668\u4E0D\u5B8C\u6574\uFF1A\u6587\u4EF6\u53EA\u6709 ${String(bytes.byteLength)} \u5B57\u8282\uFF0C\u4E0D\u8DB3\u4EE5\u5BB9\u7EB3 ${String(HEADER_BYTES)} \u5B57\u8282\u7684\u6587\u4EF6\u5934${where}`
+    );
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const recordCount = view.getUint16(NUM_RECORDS_AT, false);
+  const tableEnd = HEADER_BYTES + recordCount * RECORD_ENTRY_BYTES;
+  if (bytes.byteLength < tableEnd) {
+    throw new FormatError(
+      `PalmDB \u5BB9\u5668\u4E0D\u5B8C\u6574\uFF1A\u5934\u58F0\u79F0\u6709 ${String(recordCount)} \u6761\u8BB0\u5F55\uFF0C\u504F\u79FB\u8868\u9700\u8981 ${String(tableEnd)} \u5B57\u8282\uFF0C\u4F46\u6587\u4EF6\u53EA\u6709 ${String(bytes.byteLength)} \u5B57\u8282${where}`
+    );
+  }
+  let floor = tableEnd;
+  for (let index = 0; index < recordCount; index += 1) {
+    const offset = view.getUint32(HEADER_BYTES + index * RECORD_ENTRY_BYTES, false);
+    if (offset < floor) {
+      throw new FormatError(
+        `PalmDB \u8BB0\u5F55\u504F\u79FB\u975E\u6CD5\uFF1A\u7B2C ${String(index)} \u6761\u8BB0\u5F55\u8D77\u70B9\u4E3A ${String(offset)}\uFF0C\u5C0F\u4E8E\u5141\u8BB8\u7684\u6700\u5C0F\u503C ${String(floor)}${where}`
+      );
+    }
+    if (offset > bytes.byteLength) {
+      throw new FormatError(
+        `PalmDB \u8BB0\u5F55\u504F\u79FB\u8D8A\u754C\uFF1A\u7B2C ${String(index)} \u6761\u8BB0\u5F55\u8D77\u70B9\u4E3A ${String(offset)}\uFF0C\u8D85\u51FA\u6587\u4EF6\u957F\u5EA6 ${String(bytes.byteLength)}${where}`
+      );
+    }
+    floor = offset + 1;
+  }
+  return {
+    recordCount,
+    record(index) {
+      if (!Number.isInteger(index) || index < 0 || index >= recordCount) {
+        throw new RangeError(
+          `PalmDB \u8BB0\u5F55\u4E0B\u6807\u8D8A\u754C\uFF1A${String(index)}\uFF08\u5408\u6CD5\u8303\u56F4 0..${String(recordCount - 1)}\uFF09`
+        );
+      }
+      const start = view.getUint32(HEADER_BYTES + index * RECORD_ENTRY_BYTES, false);
+      const end = index + 1 < recordCount ? view.getUint32(HEADER_BYTES + (index + 1) * RECORD_ENTRY_BYTES, false) : bytes.byteLength;
+      return bytes.subarray(start, end);
+    }
+  };
+}
+
+// src/formats/mobi/recindex.ts
+var LATIN14 = new TextDecoder("latin1");
+var IMG_TAG = /<img\b[^>]*>/gi;
+var RECINDEX_ATTR = /\brecindex\s*=\s*("[^"]*"|'[^']*'|[^\s>]+)/i;
+var DECIMAL = /^[0-9]+$/;
+var ASCII2 = new TextEncoder();
+function rewriteRecindex(bytes, resolve, label) {
+  const raw = LATIN14.decode(bytes);
+  const edits = [];
+  const pieces = [];
+  let cursor = 0;
+  for (const match of raw.matchAll(IMG_TAG)) {
+    const [tag] = match;
+    const attribute = RECINDEX_ATTR.exec(tag);
+    if (attribute === null) continue;
+    const [, captured] = attribute;
+    const quoted = captured;
+    const value = quoted.startsWith('"') || quoted.startsWith("'") ? quoted.slice(1, -1) : quoted;
+    if (!DECIMAL.test(value)) {
+      throw new FormatError(
+        `MOBI \u7684 recindex \u4E0D\u662F\u5341\u8FDB\u5236\u6570\uFF1A"${value}"\uFF08\u57FA 32 \u7684\u503C\u542B A-V\uFF0C\u6309\u5341\u8FDB\u5236\u8BFB\u4F1A**\u9759\u9ED8**\u5F97\u5230\u9519\u503C\uFF09${sourceSuffix(label)}`
+      );
+    }
+    const at = match.index + attribute.index;
+    const replacement = ASCII2.encode(`src="${resolve(Number(value))}"`);
+    pieces.push(bytes.subarray(cursor, at), replacement);
+    edits.push({ at, removed: attribute[0].length, inserted: replacement.byteLength });
+    cursor = at + attribute[0].length;
+  }
+  if (edits.length === 0) return { bytes, edits };
+  pieces.push(bytes.subarray(cursor));
+  const total = pieces.reduce((sum, piece) => sum + piece.byteLength, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const piece of pieces) {
+    out.set(piece, offset);
+    offset += piece.byteLength;
+  }
+  return { bytes: out, edits };
+}
+function shiftOffset(edits, offset) {
+  let shifted = offset;
+  for (const edit of edits) {
+    if (offset >= edit.at + edit.removed) shifted += edit.inserted - edit.removed;
+  }
+  return shifted;
+}
+
+// src/formats/mobi/huffcdic.ts
+var HUFF_MAGIC = "HUFF";
+var CDIC_MAGIC = "CDIC";
+var HUFF_HEADER_BYTES = 24;
+var CDIC_HEADER_BYTES = 16;
+var DICT1_ENTRIES = 256;
+var MAX_CODE_LENGTH = 32;
+var TAIL_PADDING_BYTES = 8;
+var TWO_POW_32 = 4294967296;
+function magicAt(record, length) {
+  return String.fromCharCode(...record.subarray(0, length));
+}
+function requireWithin(record, at, size, what, where) {
+  if (at + size > record.byteLength) {
+    throw new FormatError(
+      `${what} \u8D8A\u754C\uFF1A\u9700\u8981\u5230 ${String(at + size)} \u5B57\u8282\uFF0C\u8BB0\u5F55\u53EA\u6709 ${String(record.byteLength)} \u5B57\u8282${where}`
+    );
+  }
+}
+function openRecord(record, magic, headerBytes, where) {
+  if (magicAt(record, magic.length) !== magic) {
+    throw new FormatError(
+      `${magic} \u8BB0\u5F55\u9B54\u6570\u4E0D\u7B26\uFF1A\u671F\u671B "${magic}"\uFF0C\u8BFB\u5230 "${magicAt(record, magic.length)}"${where}`
+    );
+  }
+  requireWithin(record, 0, headerBytes, `${magic} \u8BB0\u5F55\u5934`, where);
+  const view = new DataView(record.buffer, record.byteOffset, record.byteLength);
+  const declared = view.getUint32(4, false);
+  if (declared < headerBytes) {
+    throw new FormatError(
+      `${magic} \u8BB0\u5F55\u5934\u957F\u5EA6\u975E\u6CD5\uFF1A\u81EA\u8FF0 ${String(declared)} \u5B57\u8282\uFF0C\u5C0F\u4E8E\u8868\u5934\u81EA\u8EAB\u7684 ${String(headerBytes)} \u5B57\u8282${where}`
+    );
+  }
+  return view;
+}
+function windowAt(view, bitPos) {
+  const at = bitPos >>> 3;
+  const shift = bitPos & 7;
+  const wide = view.getUint8(at) * TWO_POW_32 + view.getUint8(at + 1) * 16777216 + view.getUint8(at + 2) * 65536 + view.getUint8(at + 3) * 256 + view.getUint8(at + 4);
+  return Math.floor(wide / 2 ** (8 - shift)) % TWO_POW_32;
+}
+function loadHuffCdic(palmdb, huff, label) {
+  const where = sourceSuffix(label);
+  if (huff.count < 1) {
+    throw new FormatError(
+      `HUFF/CDIC \u8868\u4F4D\u7F6E\u975E\u6CD5\uFF1Ahuff_num = ${String(huff.count)}\uFF08\u81F3\u5C11\u8981\u6709 HUFF \u8BB0\u5F55\u672C\u8EAB \u2014\u2014 \u8BE5\u5B57\u6BB5**\u542B** HUFF \u8BB0\u5F55\uFF09${where}`
+    );
+  }
+  const end = huff.offset + huff.count;
+  if (end > palmdb.recordCount) {
+    throw new FormatError(
+      `HUFF/CDIC \u8868\u8D8A\u754C\uFF1A\u4ECE\u8BB0\u5F55 ${String(huff.offset)} \u8D77\u8981\u88C5 ${String(huff.count)} \u6761\uFF08\u5230 ${String(end)}\uFF09\uFF0C\u5BB9\u5668\u53EA\u6709 ${String(palmdb.recordCount)} \u6761${where}`
+    );
+  }
+  const huffRecord = palmdb.record(huff.offset);
+  const huffView = openRecord(huffRecord, HUFF_MAGIC, HUFF_HEADER_BYTES, where);
+  const dict1At = huffView.getUint32(8, false);
+  const dict2At = huffView.getUint32(12, false);
+  requireWithin(huffRecord, dict1At, DICT1_ENTRIES * 4, "HUFF \u7684 dict1", where);
+  requireWithin(huffRecord, dict2At, MAX_CODE_LENGTH * 8, "HUFF \u7684 dict2", where);
+  const minCodeAt = (length) => huffView.getUint32(dict2At + (length - 1) * 8, false) * 2 ** (32 - length);
+  const maxCodeAt = (length) => (huffView.getUint32(dict2At + (length - 1) * 8 + 4, false) + 1) * 2 ** (32 - length) - 1;
+  const phrases = /* @__PURE__ */ new Map();
+  for (let index = huff.offset + 1; index < end; index += 1) {
+    const cdic = palmdb.record(index);
+    const view = openRecord(cdic, CDIC_MAGIC, CDIC_HEADER_BYTES, where);
+    const total = view.getUint32(8, false);
+    const bits = view.getUint32(12, false);
+    const slots = Math.min(2 ** bits, total - phrases.size);
+    requireWithin(cdic, CDIC_HEADER_BYTES, slots * 2, "CDIC \u7684\u504F\u79FB\u8868", where);
+    for (let slot = 0; slot < slots; slot += 1) {
+      const at = CDIC_HEADER_BYTES + view.getUint16(CDIC_HEADER_BYTES + slot * 2, false);
+      const length = view.getUint16(at, false);
+      const size = length & 32767;
+      requireWithin(cdic, at + 2, size, "CDIC \u7684\u6761\u76EE\u4F53", where);
+      phrases.set(phrases.size, {
+        body: cdic.subarray(at + 2, at + 2 + size),
+        expanded: (length & 32768) !== 0
+      });
+    }
+  }
+  const cache = /* @__PURE__ */ new Map();
+  const pending = /* @__PURE__ */ new Set();
+  function decodeStream(stream, budget) {
+    const padded = new Uint8Array(stream.byteLength + TAIL_PADDING_BYTES);
+    padded.set(stream);
+    const view = new DataView(padded.buffer);
+    const chunks = [];
+    let bitPos = 0;
+    let bitsLeft = stream.byteLength * 8;
+    let total = 0;
+    let cut = false;
+    const emit = (chunk) => {
+      chunks.push(chunk);
+      total += chunk.byteLength;
+      budget.left -= chunk.byteLength;
+    };
+    for (; ; ) {
+      if (budget.left <= 0) {
+        cut = true;
+        break;
+      }
+      const code = windowAt(view, bitPos);
+      const top = code >>> 24;
+      const packed = huffView.getUint32(dict1At + top * 4, false);
+      let length = packed & 31;
+      let limit;
+      if (length === 0) {
+        throw new ParseError(
+          `HUFF/CDIC \u7801\u957F\u4E3A 0\uFF1Adict1[${String(top)}] = ${String(packed)}${where}`
+        );
+      }
+      if ((packed & 128) !== 0) {
+        limit = ((packed >>> 8) + 1) * 2 ** (32 - length) - 1;
+      } else {
+        while (code < minCodeAt(length)) {
+          length += 1;
+          if (length > MAX_CODE_LENGTH) {
+            throw new ParseError(
+              `HUFF/CDIC \u7801\u957F\u8865\u6B63\u8D85\u8FC7 ${String(MAX_CODE_LENGTH)}\uFF1Adict1[${String(top)}] \u62A5 ${String(packed & 31)}\uFF0C\u4F46 mincode \u4E00\u76F4\u6CA1\u6EE1\u8DB3${where}`
+            );
+          }
+        }
+        limit = maxCodeAt(length);
+      }
+      bitPos += length;
+      bitsLeft -= length;
+      if (bitsLeft < 0) break;
+      const index = Math.floor((limit - code) / 2 ** (32 - length));
+      const phrase = phrases.get(index);
+      if (phrase === void 0) {
+        throw new ParseError(
+          `HUFF/CDIC \u4F4D\u6D41\u5F15\u7528\u4E86\u5B57\u5178\u5916\u7684\u4E0B\u6807\uFF1A${String(index)}\uFF08\u5B57\u5178 ${String(phrases.size)} \u6761\uFF09${where}`
+        );
+      }
+      if (phrase.expanded) {
+        emit(phrase.body);
+        continue;
+      }
+      const cached = cache.get(index);
+      if (cached !== void 0) {
+        emit(cached);
+        continue;
+      }
+      if (pending.has(index)) {
+        throw new ParseError(`HUFF/CDIC \u77ED\u8BED\u6761\u76EE\u6210\u73AF\uFF1A\u5B57\u5178\u4E0B\u6807 ${String(index)}${where}`);
+      }
+      pending.add(index);
+      const expanded = decodeStream(phrase.body, { left: budget.left });
+      pending.delete(index);
+      if (!expanded.cut) cache.set(index, expanded.bytes);
+      emit(expanded.bytes);
+    }
+    const out = new Uint8Array(total);
+    let at = 0;
+    for (const chunk of chunks) {
+      out.set(chunk, at);
+      at += chunk.byteLength;
+    }
+    return { bytes: out, cut };
+  }
+  return {
+    unpack(record, limitBytes) {
+      const budget = { left: limitBytes ?? Number.POSITIVE_INFINITY };
+      const { bytes } = decodeStream(record, budget);
+      return limitBytes === void 0 || bytes.byteLength <= limitBytes ? bytes : bytes.subarray(0, limitBytes);
+    }
+  };
+}
+
+// src/formats/mobi/palmdoc.ts
+var RUN_MAX = 8;
+var LITERAL_MAX = 127;
+var SPACE_MIN = 192;
+var PAIR_LENGTH_BASE = 3;
+var PAIR_DISTANCE_MASK = 2047;
+var SPACE = 32;
+var MAX_EXPANSION = 5;
+function decompressPalmDoc(input) {
+  const inputView = new DataView(input.buffer, input.byteOffset, input.byteLength);
+  const output = new Uint8Array(input.byteLength * MAX_EXPANSION + 2);
+  const outputView = new DataView(output.buffer);
+  let produced = 0;
+  let cursor = 0;
+  while (cursor < input.byteLength) {
+    const byte = inputView.getUint8(cursor);
+    cursor += 1;
+    if (byte >= 1 && byte <= RUN_MAX) {
+      for (let taken = 0; taken < byte && cursor < input.byteLength; taken += 1) {
+        outputView.setUint8(produced, inputView.getUint8(cursor));
+        produced += 1;
+        cursor += 1;
+      }
+      continue;
+    }
+    if (byte <= LITERAL_MAX) {
+      outputView.setUint8(produced, byte);
+      produced += 1;
+      continue;
+    }
+    if (byte >= SPACE_MIN) {
+      outputView.setUint8(produced, SPACE);
+      outputView.setUint8(produced + 1, byte ^ 128);
+      produced += 2;
+      continue;
+    }
+    if (cursor >= input.byteLength) break;
+    const pair = byte << 8 | inputView.getUint8(cursor);
+    cursor += 1;
+    const distance = pair >> 3 & PAIR_DISTANCE_MASK;
+    const length = (pair & 7) + PAIR_LENGTH_BASE;
+    if (distance > produced) {
+      throw new ParseError(
+        `PalmDOC \u8BB0\u5F55\u635F\u574F\uFF1A\u53CC\u5B57\u8282\u5BF9\u5F15\u7528\u4E86\u5C1A\u672A\u4EA7\u51FA\u7684\u5B57\u8282\uFF08\u8DDD\u79BB ${String(distance)}\uFF0C\u5DF2\u4EA7\u51FA ${String(produced)} \u5B57\u8282\uFF09`
+      );
+    }
+    for (let copied = 0; copied < length; copied += 1) {
+      outputView.setUint8(produced, outputView.getUint8(produced - distance));
+      produced += 1;
+    }
+  }
+  return output.subarray(0, produced);
+}
+
+// src/formats/mobi/text.ts
+var COMPRESSION_NONE = 1;
+var COMPRESSION_PALMDOC = 2;
+var COMPRESSION_HUFFCDIC = 17480;
+function decompressFor(compression, palmdb, mobi, label) {
+  if (compression === COMPRESSION_PALMDOC) return decompressPalmDoc;
+  if (compression === COMPRESSION_HUFFCDIC) {
+    const decoder = loadHuffCdic(palmdb, mobi.huff, label);
+    return (record, wantBytes) => decoder.unpack(record, wantBytes);
+  }
+  return (record) => record;
+}
+function readMobiText(palmdb, palmdoc, mobi, label) {
+  const where = sourceSuffix(label);
+  const { compression } = palmdoc;
+  if (compression !== COMPRESSION_NONE && compression !== COMPRESSION_PALMDOC && compression !== COMPRESSION_HUFFCDIC) {
+    throw new FormatError(
+      `MOBI \u538B\u7F29\u65B9\u5F0F ${String(compression)} \u4E0D\u53D7\u652F\u6301\uFF1A\u672C\u6279\u652F\u6301 1\uFF08\u65E0\u538B\u7F29\uFF09\u30012\uFF08PalmDOC\uFF09\u4E0E 17480\uFF08HUFF/CDIC\uFF09${where}`
+    );
+  }
+  const needed = 1 + palmdoc.textRecordCount;
+  if (palmdb.recordCount < needed) {
+    throw new FormatError(
+      `MOBI \u6B63\u6587\u8BB0\u5F55\u4E0D\u8DB3\uFF1A\u5934\u58F0\u79F0 ${String(palmdoc.textRecordCount)} \u6761\u6B63\u6587\u8BB0\u5F55\uFF08\u9700\u8981\u5BB9\u5668\u6709 ${String(needed)} \u6761\uFF09\uFF0C\u5B9E\u9645\u53EA\u6709 ${String(palmdb.recordCount)} \u6761${where}`
+    );
+  }
+  const decode = decompressFor(compression, palmdb, mobi, label);
+  const capacity = palmdoc.textRecordCount * palmdoc.maxSectionSize;
+  if (palmdoc.textLength > capacity) {
+    throw new FormatError(
+      `MOBI \u6B63\u6587\u957F\u5EA6\u4E0D\u53EF\u8FBE\uFF1A\u5934\u58F0\u79F0 ${String(palmdoc.textLength)} \u5B57\u8282\uFF0C\u4F46 ${String(palmdoc.textRecordCount)} \u6761\u6B63\u6587\u8BB0\u5F55\u6BCF\u6BB5\u81F3\u591A\u4EA7\u51FA ${String(palmdoc.maxSectionSize)} \u5B57\u8282 \u21D2 \u81F3\u591A ${String(capacity)} \u5B57\u8282${where}`
+    );
+  }
+  const out = new Uint8Array(palmdoc.textLength);
+  let produced = 0;
+  for (let index = 1; index <= palmdoc.textRecordCount; index += 1) {
+    const remaining = palmdoc.textLength - produced;
+    if (remaining <= 0) break;
+    const want = Math.min(palmdoc.maxSectionSize, remaining);
+    const decoded = decode(palmdb.record(index), want);
+    const take = Math.min(want, decoded.byteLength);
+    out.set(decoded.subarray(0, take), produced);
+    produced += take;
+  }
+  if (produced !== palmdoc.textLength) {
+    throw new FormatError(
+      `MOBI \u6B63\u6587\u957F\u5EA6\u4E0D\u7B26\uFF1A\u5934\u58F0\u79F0 ${String(palmdoc.textLength)} \u5B57\u8282\uFF0C\u4F46 ${String(palmdoc.textRecordCount)} \u6761\u8BB0\u5F55\u53EA\u62FC\u51FA ${String(produced)} \u5B57\u8282${where}`
+    );
+  }
+  return out;
+}
+
+// src/formats/mobi/toc.ts
+var MOBI_TEXT_NAME = "text.html";
+var LATIN15 = new TextDecoder("latin1");
+var GUIDE_TAG = /<reference\b[^>]*\btype\s*=\s*"toc"[^>]*>/i;
+var FILEPOS_IN_TAG = /\bfilepos\s*=\s*"?([0-9]+)/i;
+var INLINE_TAG = /<[^>]*>/g;
+function collectAnchors(raw, from, to) {
+  const region = raw.slice(from, to);
+  const starts = /<a[\s>]/gi;
+  const hits = [];
+  for (let match = starts.exec(region); match !== null; match = starts.exec(region)) {
+    const tagEnd = region.indexOf(">", match.index);
+    if (tagEnd === -1) break;
+    const digits = FILEPOS_IN_TAG.exec(region.slice(match.index, tagEnd))?.[1];
+    if (digits === void 0) continue;
+    const closeAt = region.indexOf("</a>", tagEnd);
+    if (closeAt === -1) continue;
+    hits.push({
+      filepos: Number(digits),
+      labelStart: from + tagEnd + 1,
+      labelEnd: from + closeAt
+    });
+  }
+  return hits;
+}
+function decodeLabel(bytes, decoder) {
+  return decoder.decode(bytes).replace(INLINE_TAG, "").trim();
+}
+function parseMobiToc(text, codepage = UTF8_CODEPAGE, label) {
+  if (text.byteLength === 0) return [];
+  const raw = LATIN15.decode(text);
+  const guideTag = GUIDE_TAG.exec(raw)?.[0];
+  const fileposText = guideTag === void 0 ? void 0 : FILEPOS_IN_TAG.exec(guideTag)?.[1];
+  if (fileposText === void 0) return [];
+  const guideAt = Number(fileposText);
+  if (guideAt > text.byteLength) {
+    throw new FormatError(
+      `MOBI \u76EE\u5F55\u7EBF\u7D22\u8D8A\u754C\uFF1Aguide \u7684 <reference type="toc"> \u6307\u5411 filepos ${String(guideAt)}\uFF0C\u8D85\u51FA\u6B63\u6587\u957F\u5EA6 ${String(text.byteLength)}${sourceSuffix(label)}`
+    );
+  }
+  const pagebreakAt = raw.indexOf("<mbp:pagebreak", guideAt);
+  const end = pagebreakAt === -1 ? text.byteLength : pagebreakAt;
+  const decoder = decoderFor(codepage);
+  return collectAnchors(raw, guideAt, end).map((hit) => ({
+    label: decodeLabel(text.subarray(hit.labelStart, hit.labelEnd), decoder),
+    href: MOBI_TEXT_NAME,
+    fragment: String(hit.filepos),
+    children: []
+  }));
+}
+
+// src/formats/mobi/open.ts
+var EXTH_AUTHOR = 100;
+var EXTH_ISBN = 104;
+var EXTH_ASIN = 113;
+var EXTH_TITLE = 503;
+var EXTH_LANGUAGE = 524;
+var TEXT_MEDIA_TYPE = "text/html";
+var KF8_CHAPTER_MEDIA_TYPE = "application/xhtml+xml";
+var UNKNOWN_MEDIA_TYPE = "application/octet-stream";
+var MEDIA_EXTENSIONS = /* @__PURE__ */ new Map([
+  ["text/css", "css"],
+  ["image/jpeg", "jpg"],
+  ["image/png", "png"],
+  ["image/gif", "gif"],
+  ["image/svg", "svg"],
+  ["image/svg+xml", "svg"]
+]);
+function extensionFor(mediaType) {
+  return MEDIA_EXTENSIONS.get(mediaType) ?? "bin";
+}
+var IMAGE_MAGICS = [
+  ["image/jpeg", [255, 216, 255]],
+  ["image/png", [137, 80, 78, 71]],
+  ["image/gif", [71, 73, 70, 56]]
+];
+function imageKind(bytes) {
+  for (const [mediaType, magic] of IMAGE_MAGICS) {
+    if (magic.every((byte, index) => bytes[index] === byte)) {
+      return mediaType;
+    }
+  }
+  return void 0;
+}
+function imageName(record, mediaType) {
+  return `images/${String(record)}.${extensionFor(mediaType)}`;
+}
+function archiveRootReference(name) {
+  return `/${name}`;
+}
+function assertRecordInRange(palmdb, record, describe, label) {
+  if (record < 1 || record >= palmdb.recordCount) {
+    throw new FormatError(
+      `${describe} \u6307\u5411\u8BB0\u5F55 ${String(record)}\uFF0C\u8D8A\u51FA\u5BB9\u5668\uFF08\u5171 ${String(palmdb.recordCount)} \u6761\uFF09${sourceSuffix(label)}`
+    );
+  }
+}
+function collectImages(palmdb, header) {
+  const images = [];
+  const from = Math.max(header.firstResourceRecord, 1);
+  for (let index = from; index < palmdb.recordCount; index += 1) {
+    const bytes = palmdb.record(index);
+    const mediaType = imageKind(bytes);
+    if (mediaType === void 0) continue;
+    images.push({
+      record: index,
+      href: imageName(index, mediaType),
+      mediaType,
+      bytes
+    });
+  }
+  return images;
+}
+function readFullName(palmdb, header, label) {
+  if (header.fullNameLength === 0) return void 0;
+  const record = palmdb.record(0);
+  const end = header.fullNameOffset + header.fullNameLength;
+  if (end > record.byteLength) {
+    throw new FormatError(
+      `MOBI \u5B8C\u6574\u4E66\u540D\u8D8A\u754C\uFF1A${String(header.fullNameOffset)}..${String(end)} \u8D85\u51FA\u8BB0\u5F55 0 \u7684 ${String(record.byteLength)} \u5B57\u8282${sourceSuffix(label)}`
+    );
+  }
+  return decoderFor(header.codepage).decode(record.subarray(header.fullNameOffset, end));
+}
+function readMetadata(palmdb, header, label) {
+  const where = sourceSuffix(label);
+  const { exth, codepage } = header;
+  const title = exthTexts(exth, EXTH_TITLE, codepage)[0] ?? readFullName(palmdb, header, label);
+  if (title === void 0 || title.length === 0) {
+    throw new FormatError(
+      `MOBI \u7F3A\u5C11\u4E66\u540D\uFF1AEXTH ${String(EXTH_TITLE)} \u4E0E MOBI \u5B8C\u6574\u4E66\u540D\u90FD\u6CA1\u6709${where}`
+    );
+  }
+  const language = exthTexts(exth, EXTH_LANGUAGE, codepage)[0];
+  if (language === void 0 || language.length === 0) {
+    throw new FormatError(
+      `MOBI \u7F3A\u5C11\u8BED\u8A00\uFF1AEXTH ${String(EXTH_LANGUAGE)} \u4E0D\u5B58\u5728\uFF0C\u800C\u6A21\u578B\u91CC language \u662F\u5FC5\u586B${where}`
+    );
+  }
+  const identifier = exthTexts(exth, EXTH_ISBN, codepage)[0] ?? exthTexts(exth, EXTH_ASIN, codepage)[0] ?? "";
+  return {
+    title,
+    creators: exthTexts(exth, EXTH_AUTHOR, codepage),
+    language,
+    identifier
+  };
+}
+function createContent(entries, codepage) {
+  const decoder = decoderFor(codepage);
+  const read = (name, readOptions) => (
+    // 同步体推进微任务队列 ⇒ 抛出的错误自然成为拒绝（不依赖调用方套 `try`）。
+    Promise.resolve().then(() => {
+      throwIfAborted(readOptions?.signal);
+      const bytes = entries.get(name);
+      if (bytes === void 0) {
+        throw new FormatError(`MOBI \u5185\u5BB9\u6E90\u91CC\u6CA1\u6709 "${name}"`);
+      }
+      return bytes;
+    })
+  );
+  const readText = async (name, readOptions) => {
+    const decoded = decoder.decode(await read(name, readOptions));
+    return decoded.startsWith("\uFEFF") ? decoded.slice(1) : decoded;
+  };
+  return { read, readText };
+}
+function openSync(bytes, source) {
+  const palmdb = parsePalmDb(bytes, source);
+  const palmdoc = parsePalmDocHeader(palmdb, source);
+  const header = parseMobiHeader(palmdb, source);
+  const text = readMobiText(palmdb, palmdoc, header, source);
+  return header.fileVersion === KF8_FILE_VERSION ? openKf8(palmdb, header, text, source) : openMobi6(palmdb, header, text, source);
+}
+function openMobi6(palmdb, header, text, source) {
+  const where = sourceSuffix(source);
+  const toc = parseMobiToc(text, header.codepage, source);
+  const images = collectImages(palmdb, header);
+  const byRecord = new Map(images.map((image) => [image.record, image]));
+  const rewrite = rewriteRecindex(
+    text,
+    (index) => {
+      const record = header.firstResourceRecord + index - 1;
+      const describe = `MOBI \u7684 \`recindex="${String(index)}"\``;
+      assertRecordInRange(palmdb, record, describe, source);
+      const image = byRecord.get(record);
+      if (image === void 0) {
+        throw new FormatError(`${describe} \u6307\u5411\u8BB0\u5F55 ${String(record)}\uFF0C\u4F46\u8BE5\u8BB0\u5F55\u4E0D\u662F\u56FE\u7247${where}`);
+      }
+      return archiveRootReference(image.href);
+    },
+    source
+  );
+  const resolved = toc.map((item) => ({
+    item,
+    at: shiftOffset(rewrite.edits, Number(item.fragment))
+  }));
+  const anchors = injectAnchors(
+    rewrite.bytes,
+    resolved.map((entry) => entry.at)
+  );
+  const idAt = /* @__PURE__ */ new Map();
+  for (const placement of anchors.placements) {
+    if (placement.kind === "open-tag") idAt.set(placement.at, placement.id);
+  }
+  const entries = /* @__PURE__ */ new Map([[MOBI_TEXT_NAME, anchors.bytes]]);
+  for (const image of images) entries.set(image.href, image.bytes);
+  return {
+    content: createContent(entries, header.codepage),
+    book: {
+      format: "mobi",
+      metadata: readMetadata(palmdb, header, source),
+      resources: images.map((image) => ({ href: image.href, mediaType: image.mediaType })),
+      // MOBI6 的正文是**单个** HTML 文档（事实 6）⇒ 阅读顺序只有一条，
+      // 分节靠目录项的 `fragment`（元素 id，见 `anchors.ts`）。
+      chapters: [{ href: MOBI_TEXT_NAME, mediaType: TEXT_MEDIA_TYPE, linear: true }],
+      // 以下为 EPUB 专属：非 OPF 格式取空值（ADR-0014 的字段分层）。
+      manifest: [],
+      spine: [],
+      manifestIndex: /* @__PURE__ */ new Map()
+    },
+    // 落点是开标签 ⇒ `fragment` 是该元素的 **id**（渲染层 `getElementById` 命中）；
+    // 降级时保留换算后的**字节偏移**（渲染层查不到 ⇒ 回退章首），与 ④ 之前逐字相同。
+    toc: resolved.map(({ item, at }) => ({ ...item, fragment: idAt.get(at) ?? String(at) }))
+  };
+}
+function openKf8(palmdb, header, text, source) {
+  const where = sourceSuffix(source);
+  const flows = parseFlows(palmdb, header, text.byteLength, source);
+  const entries = /* @__PURE__ */ new Map();
+  const resources = [];
+  const register = (name, mediaType, bytes) => {
+    if (!entries.has(name)) {
+      entries.set(name, bytes);
+      resources.push({ href: name, mediaType });
+    }
+    return name;
+  };
+  const resolve = (kind, index, mime) => {
+    const mediaType = mime ?? UNKNOWN_MEDIA_TYPE;
+    if (kind === "flow") {
+      const span = flows[index];
+      if (span === void 0) {
+        throw new FormatError(
+          `KF8 \u7684 \`kindle:flow:${String(index)}\` \u8D8A\u51FA FDST \u7684 ${String(flows.length)} \u6BB5${where}`
+        );
+      }
+      return archiveRootReference(
+        register(
+          `flows/${String(index).padStart(4, "0")}.${extensionFor(mediaType)}`,
+          mediaType,
+          text.subarray(span.start, span.end)
+        )
+      );
+    }
+    const record = header.firstResourceRecord + index - 1;
+    assertRecordInRange(palmdb, record, `KF8 \u7684 \`kindle:embed:${String(index)}\``, source);
+    return archiveRootReference(
+      register(imageName(record, mediaType), mediaType, palmdb.record(record))
+    );
+  };
+  const first = flows[0];
+  const flow0 = text.subarray(first.start, first.end);
+  const documents = splitKf8Documents(flow0, source);
+  const chapters = [];
+  documents.forEach((document, index) => {
+    const href = `text/${String(index).padStart(4, "0")}.xhtml`;
+    entries.set(href, rewriteKindleUris(document, resolve, source));
+    chapters.push({ href, mediaType: KF8_CHAPTER_MEDIA_TYPE, linear: true });
+  });
+  return {
+    content: createContent(entries, header.codepage),
+    book: {
+      format: "mobi",
+      metadata: readMetadata(palmdb, header, source),
+      resources,
+      chapters,
+      // 以下为 EPUB 专属：非 OPF 格式取空值（ADR-0014 的字段分层）。
+      manifest: [],
+      spine: [],
+      manifestIndex: /* @__PURE__ */ new Map()
+    },
+    // ⚠️ 反搜元素 id 必须用 `documents`（`kindle:` URI **重写之前**的字节）：
+    // 重写会把 `kindle:flow:0001` 换成更长的归档路径、**字节长度变了**，
+    // 于是目录项的字节偏移 `q` 不再指向原处（见 `kf8toc.ts` 文件头）。
+    toc: parseKf8Toc(palmdb, header, flow0, documents, source)
+  };
+}
+function openMobi(bytes, options) {
+  return Promise.resolve().then(() => {
+    throwIfAborted(options?.signal);
+    return openSync(bytes, options?.source);
+  });
+}
+
+// src/formats/mobi/adapter.ts
+var mobiAdapter = {
+  format: "mobi",
+  async open(bytes, options) {
+    return openMobi(bytes, options);
+  }
+};
+
+export { mobiAdapter };