frond-js 0.4.0

package/dist/chunk-SJVOYNTF.js

@@ -0,0 +1,425 @@
+import { resolveBookBytes } from './chunk-JJVXT3AC.js';
+import { parseXml, findAll, getAttribute, findFirst, getText } from './chunk-D4KWSEZD.js';
+import { parseZip } from './chunk-UY2YRCFC.js';
+import { resolveArchivePath, directoryOf } from './chunk-U4264IQH.js';
+import { throwIfAborted, isAbortError, ParseError, FormatError } from './chunk-B2L2YVXD.js';
+
+// src/formats/epub/container.ts
+var EPUB_PACKAGE_MEDIA_TYPE = "application/oebps-package+xml";
+var DEFAULT_CONTAINER_PATH = "META-INF/container.xml";
+function formatError(message, source) {
+  return new FormatError(`${message}\uFF08\u6E90: ${source}\uFF09`);
+}
+function toContainerError(error, source, containerPath) {
+  const detail = error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF";
+  const message = `${detail}\uFF08container: ${containerPath}\uFF0C\u6E90: ${source}\uFF09`;
+  return error instanceof ParseError ? new ParseError(message, { cause: error }) : new FormatError(message, { cause: error });
+}
+async function parseContainer(archive, options = {}) {
+  const containerPath = options.containerPath ?? DEFAULT_CONTAINER_PATH;
+  const source = options.source ?? containerPath;
+  throwIfAborted(options.signal);
+  let xml;
+  try {
+    xml = await archive.readText(
+      containerPath,
+      options.signal === void 0 ? {} : { signal: options.signal }
+    );
+  } catch (error) {
+    if (isAbortError(error)) throw error;
+    throw toContainerError(error, source, containerPath);
+  }
+  throwIfAborted(options.signal);
+  const document = parseXml(xml, { source });
+  for (const rootfile of findAll(document, "rootfile")) {
+    if (getAttribute(rootfile, "media-type") !== EPUB_PACKAGE_MEDIA_TYPE) continue;
+    const rawPath = getAttribute(rootfile, "full-path");
+    if (rawPath === void 0) {
+      throw formatError("rootfile \u7F3A\u5C11 full-path \u5C5E\u6027", source);
+    }
+    return {
+      opfPath: resolveArchivePath("", rawPath, {
+        label: "rootfile \u7684 full-path",
+        source
+      }),
+      mediaType: EPUB_PACKAGE_MEDIA_TYPE
+    };
+  }
+  throw formatError(
+    `container \u4E2D\u6CA1\u6709\u53D7\u652F\u6301\u7684 package rootfile\uFF08\u671F\u671B media-type="${EPUB_PACKAGE_MEDIA_TYPE}"\uFF09`,
+    source
+  );
+}
+
+// src/formats/epub/opf.ts
+var PACKAGE_LOCAL_NAME = "package";
+function formatError2(message, source) {
+  return new FormatError(`${message}\uFF08\u6E90: ${source}\uFF09`);
+}
+function toOpfError(error, source, opfPath) {
+  const detail = error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF";
+  const message = `${detail}\uFF08OPF: ${opfPath}\uFF0C\u6E90: ${source}\uFF09`;
+  return error instanceof ParseError ? new ParseError(message, { cause: error }) : new FormatError(message, { cause: error });
+}
+function textOf(element) {
+  return getText(element).trim();
+}
+function firstNonEmptyText(root, localName) {
+  for (const element of findAll(root, localName)) {
+    const text = textOf(element);
+    if (text !== "") return text;
+  }
+  return void 0;
+}
+function stripFragment(href) {
+  const index = href.indexOf("#");
+  return index === -1 ? href : href.slice(0, index);
+}
+function resolveIdentifier(metadataElement, packageElement, source) {
+  const identifiers = findAll(metadataElement, "identifier");
+  if (identifiers.length === 0) {
+    throw formatError2("\u7F3A\u5C11\u5FC5\u9700\u7684 dc:identifier", source);
+  }
+  const uniqueId = getAttribute(packageElement, "unique-identifier");
+  if (uniqueId !== void 0 && uniqueId !== "") {
+    const matched = identifiers.find((element) => getAttribute(element, "id") === uniqueId);
+    if (matched === void 0) {
+      throw formatError2(
+        `package@unique-identifier \u6307\u5411\u4E0D\u5B58\u5728\u7684 dc:identifier\uFF08id="${uniqueId}"\uFF09`,
+        source
+      );
+    }
+    const text = textOf(matched);
+    if (text === "") {
+      throw formatError2(`dc:identifier\uFF08id="${uniqueId}"\uFF09\u4E3A\u7A7A`, source);
+    }
+    return text;
+  }
+  const fallback = identifiers.map(textOf).find((text) => text !== "");
+  if (fallback === void 0) {
+    throw formatError2("\u7F3A\u5C11\u5FC5\u9700\u7684 dc:identifier", source);
+  }
+  return fallback;
+}
+function resolveModified(metadataElement) {
+  for (const element of findAll(metadataElement, "meta")) {
+    if (getAttribute(element, "property") !== "dcterms:modified") continue;
+    const text = textOf(element);
+    if (text !== "") return text;
+  }
+  return void 0;
+}
+function buildMetadata(metadataElement, packageElement, source) {
+  const title = firstNonEmptyText(metadataElement, "title");
+  if (title === void 0) {
+    throw formatError2("\u7F3A\u5C11\u5FC5\u9700\u7684 dc:title", source);
+  }
+  const language = firstNonEmptyText(metadataElement, "language");
+  if (language === void 0) {
+    throw formatError2("\u7F3A\u5C11\u5FC5\u9700\u7684 dc:language", source);
+  }
+  const creators = findAll(metadataElement, "creator").map(textOf).filter((text) => text !== "");
+  const identifier = resolveIdentifier(metadataElement, packageElement, source);
+  const modified = resolveModified(metadataElement);
+  return {
+    title,
+    creators,
+    language,
+    identifier,
+    ...modified === void 0 ? {} : { modified }
+  };
+}
+function buildManifest(manifestElement, basePath, source, signal) {
+  const items = [];
+  const seenIds = /* @__PURE__ */ new Set();
+  for (const element of findAll(manifestElement, "item")) {
+    throwIfAborted(signal);
+    const id = getAttribute(element, "id");
+    if (id === void 0 || id === "") {
+      throw formatError2("manifest \u7684 <item> \u7F3A\u5C11 id \u5C5E\u6027", source);
+    }
+    if (seenIds.has(id)) {
+      throw formatError2(`manifest \u4E2D\u5B58\u5728\u91CD\u590D id="${id}"`, source);
+    }
+    seenIds.add(id);
+    const rawHref = getAttribute(element, "href");
+    if (rawHref === void 0 || rawHref === "") {
+      throw formatError2(`manifest item "${id}" \u7F3A\u5C11 href \u5C5E\u6027`, source);
+    }
+    const mediaType = getAttribute(element, "media-type");
+    if (mediaType === void 0 || mediaType === "") {
+      throw formatError2(`manifest item "${id}" \u7F3A\u5C11 media-type \u5C5E\u6027`, source);
+    }
+    const properties = (getAttribute(element, "properties") ?? "").split(/\s+/).filter((property) => property !== "");
+    const href = resolveArchivePath(basePath, stripFragment(rawHref), {
+      label: `manifest item "${id}" \u7684 href`,
+      source
+    });
+    items.push({ id, href, mediaType, properties });
+  }
+  return items;
+}
+function buildSpine(spineElement, manifestIndex, source, signal) {
+  const spine = [];
+  let index = 0;
+  for (const element of findAll(spineElement, "itemref")) {
+    throwIfAborted(signal);
+    const idref = getAttribute(element, "idref");
+    if (idref === void 0 || idref === "") {
+      throw formatError2("spine \u7684 <itemref> \u7F3A\u5C11 idref \u5C5E\u6027", source);
+    }
+    const item = manifestIndex.get(idref);
+    if (item === void 0) {
+      throw formatError2(`spine \u7684 <itemref> \u5F15\u7528\u4E86\u4E0D\u5B58\u5728\u7684 manifest id="${idref}"`, source);
+    }
+    const linear = getAttribute(element, "linear") !== "no";
+    spine.push({ idref, linear, index, item });
+    index += 1;
+  }
+  return spine;
+}
+function resolveNcxPath(spineElement, manifestIndex) {
+  const tocId = getAttribute(spineElement, "toc");
+  if (tocId === void 0 || tocId === "") return void 0;
+  return manifestIndex.get(tocId)?.href;
+}
+function resolveDirection(spineElement) {
+  const raw = getAttribute(spineElement, "page-progression-direction")?.trim().toLowerCase();
+  return raw === "ltr" || raw === "rtl" ? raw : void 0;
+}
+function buildBook(document, opfPath, source, signal) {
+  if (document.localName !== PACKAGE_LOCAL_NAME) {
+    throw formatError2(`OPF \u6839\u5143\u7D20\u5E94\u4E3A <package>\uFF0C\u5B9E\u9645\u4E3A <${document.name}>`, source);
+  }
+  const metadataElement = findFirst(document, "metadata");
+  if (metadataElement === void 0) {
+    throw formatError2("\u7F3A\u5C11 <metadata> \u5143\u7D20", source);
+  }
+  const manifestElement = findFirst(document, "manifest");
+  if (manifestElement === void 0) {
+    throw formatError2("\u7F3A\u5C11 <manifest> \u5143\u7D20", source);
+  }
+  const spineElement = findFirst(document, "spine");
+  if (spineElement === void 0) {
+    throw formatError2("\u7F3A\u5C11 <spine> \u5143\u7D20", source);
+  }
+  const basePath = directoryOf(opfPath);
+  const metadata = buildMetadata(metadataElement, document, source);
+  const manifest = buildManifest(manifestElement, basePath, source, signal);
+  const manifestIndex = new Map(manifest.map((item) => [item.id, item]));
+  const spine = buildSpine(spineElement, manifestIndex, source, signal);
+  const ncxPath = resolveNcxPath(spineElement, manifestIndex);
+  const direction = resolveDirection(spineElement);
+  const tocItem = manifest.find((item) => item.properties.includes("nav"));
+  const resources = manifest.map(({ href, mediaType }) => ({ href, mediaType }));
+  const chapters = spine.map(({ item, linear }) => ({
+    href: item.href,
+    mediaType: item.mediaType,
+    linear
+  }));
+  return {
+    format: "epub",
+    metadata,
+    resources,
+    chapters,
+    opfPath,
+    basePath,
+    manifest,
+    spine,
+    manifestIndex,
+    // exactOptionalPropertyTypes：可选字段不能显式传 `undefined`。
+    ...tocItem === void 0 ? {} : { tocItem },
+    ...ncxPath === void 0 ? {} : { ncxPath },
+    // 同上。`direction` 在「缺省 / `default` / 非法值」三种情况下都缺席（见 `resolveDirection`）。
+    ...direction === void 0 ? {} : { direction }
+  };
+}
+async function parseOpf(archive, opfPath, options = {}) {
+  const source = options.source ?? opfPath;
+  throwIfAborted(options.signal);
+  let xml;
+  try {
+    xml = await archive.readText(
+      opfPath,
+      options.signal === void 0 ? {} : { signal: options.signal }
+    );
+  } catch (error) {
+    if (isAbortError(error)) throw error;
+    throw toOpfError(error, source, opfPath);
+  }
+  throwIfAborted(options.signal);
+  const document = parseXml(xml, { source });
+  return buildBook(document, opfPath, source, options.signal);
+}
+
+// src/formats/epub/nav.ts
+function formatError3(message, source) {
+  return new FormatError(`${message}\uFF08\u6E90: ${source}\uFF09`);
+}
+function toTocError(error, source, documentPath) {
+  const detail = error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF";
+  const message = `${detail}\uFF08\u76EE\u5F55: ${documentPath}\uFF0C\u6E90: ${source}\uFF09`;
+  return error instanceof ParseError ? new ParseError(message, { cause: error }) : new FormatError(message, { cause: error });
+}
+function directChildren(element, localName) {
+  const matched = [];
+  for (const child of element.children) {
+    if (child.type !== "element") continue;
+    if (child.localName === localName) matched.push(child);
+  }
+  return matched;
+}
+function firstDirectChild(element, localName) {
+  for (const child of element.children) {
+    if (child.type === "element" && child.localName === localName) return child;
+  }
+  return void 0;
+}
+function typeTokens(element) {
+  for (const [name, value] of element.attributes) {
+    if (name === "epub:type" || name.endsWith(":type")) {
+      return value.split(/\s+/).filter((token) => token !== "");
+    }
+  }
+  return [];
+}
+function textOf2(element) {
+  return getText(element).trim();
+}
+function splitReference(raw) {
+  const index = raw.indexOf("#");
+  if (index === -1) return { path: raw };
+  const fragment = raw.slice(index + 1);
+  return { path: raw.slice(0, index), ...fragment === "" ? {} : { fragment } };
+}
+function resolveTarget(raw, context, label) {
+  const { path, fragment } = splitReference(raw);
+  const href = path === "" ? context.documentPath : resolveArchivePath(directoryOf(context.documentPath), path, {
+    label,
+    source: context.source
+  });
+  return { href, ...fragment === void 0 ? {} : { fragment } };
+}
+function buildItem(label, target, children) {
+  return {
+    label,
+    href: target.href,
+    ...target.fragment === void 0 ? {} : { fragment: target.fragment },
+    children
+  };
+}
+function selectTocNav(document) {
+  const navs = findAll(document, "nav");
+  if (navs.length === 0) return void 0;
+  return navs.find((nav) => typeTokens(nav).includes("toc")) ?? navs[0];
+}
+function parseNavList(olElement, context) {
+  const items = [];
+  for (const li of directChildren(olElement, "li")) {
+    throwIfAborted(context.signal);
+    items.push(parseNavItem(li, context));
+  }
+  return items;
+}
+function parseNavItem(li, context) {
+  const anchor = firstDirectChild(li, "a");
+  if (anchor === void 0) {
+    const span = firstDirectChild(li, "span");
+    throw formatError3(
+      span === void 0 ? "\u76EE\u5F55\u9879\u7684 <li> \u5185\u7F3A\u5C11 <a> \u5143\u7D20" : "\u76EE\u5F55\u9879\u53EA\u6709 <span>\uFF08\u65E0\u76EE\u6807\u94FE\u63A5\uFF09\uFF0C\u672C\u5B9E\u73B0\u8981\u6C42\u76EE\u5F55\u9879\u5FC5\u987B\u6307\u5411\u5177\u4F53\u6587\u6863",
+      context.source
+    );
+  }
+  const label = textOf2(anchor);
+  const rawHref = getAttribute(anchor, "href");
+  if (rawHref === void 0 || rawHref === "") {
+    throw formatError3(`\u76EE\u5F55\u9879\u7684 <a> \u7F3A\u5C11 href \u5C5E\u6027\uFF08label: "${label}"\uFF09`, context.source);
+  }
+  const target = resolveTarget(rawHref, context, `\u76EE\u5F55\u9879 "${label}" \u7684 href`);
+  const children = [];
+  for (const nested of directChildren(li, "ol")) {
+    children.push(...parseNavList(nested, context));
+  }
+  return buildItem(label, target, children);
+}
+function parseNavDocument(document, context) {
+  const nav = selectTocNav(document);
+  if (nav === void 0) return [];
+  const items = [];
+  for (const ol of directChildren(nav, "ol")) {
+    items.push(...parseNavList(ol, context));
+  }
+  return items;
+}
+function parseNcxPoints(points, context) {
+  const items = [];
+  for (const point of points) {
+    throwIfAborted(context.signal);
+    const labelElement = firstDirectChild(point, "navLabel");
+    const label = labelElement === void 0 ? "" : textOf2(labelElement);
+    const content = firstDirectChild(point, "content");
+    const rawSrc = content === void 0 ? void 0 : getAttribute(content, "src");
+    if (rawSrc === void 0 || rawSrc === "") {
+      throw formatError3(`navPoint \u7F3A\u5C11 content@src\uFF08label: "${label}"\uFF09`, context.source);
+    }
+    const target = resolveTarget(rawSrc, context, `navPoint "${label}" \u7684 content@src`);
+    const children = parseNcxPoints(directChildren(point, "navPoint"), context);
+    items.push(buildItem(label, target, children));
+  }
+  return items;
+}
+function parseNcxDocument(document, context) {
+  const navMap = firstDirectChild(document, "navMap");
+  if (navMap === void 0) return [];
+  return parseNcxPoints(directChildren(navMap, "navPoint"), context);
+}
+async function readAndParse(archive, documentPath, context, parse) {
+  throwIfAborted(context.signal);
+  let xml;
+  try {
+    xml = await archive.readText(
+      documentPath,
+      context.signal === void 0 ? {} : { signal: context.signal }
+    );
+  } catch (error) {
+    if (isAbortError(error)) throw error;
+    throw toTocError(error, context.source, documentPath);
+  }
+  throwIfAborted(context.signal);
+  return parse(parseXml(xml, { source: context.source }), context);
+}
+async function parseToc(archive, book, options = {}) {
+  const navItem = book.tocItem;
+  if (navItem !== void 0) {
+    const context = {
+      documentPath: navItem.href,
+      source: options.source ?? navItem.href,
+      signal: options.signal
+    };
+    return readAndParse(archive, navItem.href, context, parseNavDocument);
+  }
+  const ncxPath = book.ncxPath;
+  if (ncxPath !== void 0) {
+    const context = {
+      documentPath: ncxPath,
+      source: options.source ?? ncxPath,
+      signal: options.signal
+    };
+    return readAndParse(archive, ncxPath, context, parseNcxDocument);
+  }
+  throwIfAborted(options.signal);
+  return [];
+}
+
+// src/formats/epub/open.ts
+async function openBook(source, options = {}) {
+  throwIfAborted(options.signal);
+  const bytes = await resolveBookBytes(source, options);
+  const archive = parseZip(bytes, options);
+  const container = await parseContainer(archive, options);
+  const book = await parseOpf(archive, container.opfPath, options);
+  const toc = await parseToc(archive, book, options);
+  return { archive, book, toc };
+}
+
+export { openBook, parseContainer, parseOpf, parseToc };

package/dist/chunk-SLI2YL25.cjs

@@ -0,0 +1,252 @@
+'use strict';
+
+var chunkIIV6VIUJ_cjs = require('./chunk-IIV6VIUJ.cjs');
+var chunkG7DLWGBW_cjs = require('./chunk-G7DLWGBW.cjs');
+
+// src/core/zip/inflate.ts
+var CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let index = 0; index < 256; index += 1) {
+    let value = index;
+    for (let bit = 0; bit < 8; bit += 1) {
+      value = (value & 1) !== 0 ? 3988292384 ^ value >>> 1 : value >>> 1;
+    }
+    table[index] = value >>> 0;
+  }
+  return new DataView(table.buffer);
+})();
+function crc32(data) {
+  let crc = 4294967295;
+  for (const byte of data) {
+    crc = crc >>> 8 ^ CRC_TABLE.getUint32(((crc ^ byte) & 255) << 2, true);
+  }
+  return (crc ^ 4294967295) >>> 0;
+}
+async function inflateRaw(data, label, maxOutputBytes) {
+  const chunks = [];
+  let total = 0;
+  try {
+    const view = data.buffer instanceof ArrayBuffer ? new Uint8Array(data.buffer, data.byteOffset, data.byteLength) : new Uint8Array(data);
+    const stream = new Blob([view]).stream().pipeThrough(new DecompressionStream("deflate-raw"));
+    const reader = stream.getReader();
+    for (; ; ) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      total += value.byteLength;
+      if (total > maxOutputBytes) {
+        await reader.cancel();
+        throw new chunkG7DLWGBW_cjs.ParseError(
+          `deflate \u89E3\u538B\u4EA7\u7269\u8D85\u8FC7\u4E0A\u9650 ${String(maxOutputBytes)} \u5B57\u8282\uFF08\u6E90: ${label}\uFF09\uFF0C\u5DF2\u4EA7\u51FA ${String(total)} \u5B57\u8282\u5373\u4E2D\u6B62`
+        );
+      }
+      chunks.push(value);
+    }
+  } catch (error) {
+    if (chunkG7DLWGBW_cjs.isFrondError(error)) throw error;
+    throw new chunkG7DLWGBW_cjs.ParseError(`deflate \u89E3\u538B\u5931\u8D25\uFF08\u6E90: ${label}\uFF09`, { cause: error });
+  }
+  const out = new Uint8Array(total);
+  let pos = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, pos);
+    pos += chunk.byteLength;
+  }
+  return out;
+}
+
+// src/core/zip/parse.ts
+var SIGNATURE_EOCD = 101010256;
+var SIGNATURE_CENTRAL = 33639248;
+var SIGNATURE_LOCAL = 67324752;
+var EOCD_SIZE = 22;
+var EOCD_MAX_COMMENT = 65535;
+var CENTRAL_HEADER_SIZE = 46;
+var LOCAL_HEADER_SIZE = 30;
+var ZIP64_EXTRA_ID = 1;
+var FLAG_ENCRYPTED = 1;
+var METHOD_STORED = 0;
+var METHOD_DEFLATE = 8;
+var SENTINEL_16 = 65535;
+var SENTINEL_32 = 4294967295;
+var DEFAULT_MAX_ENTRY_SIZE_BYTES = 64 * 1024 * 1024;
+var textDecoder = new TextDecoder("utf-8");
+function fail(reason, offset, label) {
+  throw new chunkG7DLWGBW_cjs.ParseError(`ZIP \u89E3\u6790\u5931\u8D25\uFF1A${reason}\uFF08\u6E90: ${label}\uFF0C\u504F\u79FB ${String(offset)}\uFF09`);
+}
+function formatFail(reason, label) {
+  throw new chunkG7DLWGBW_cjs.FormatError(`ZIP \u683C\u5F0F\u4E0D\u53D7\u652F\u6301\uFF1A${reason}\uFF08\u6E90: ${label}\uFF09`);
+}
+function toMethod(value, name, label) {
+  if (value === METHOD_STORED) return METHOD_STORED;
+  if (value === METHOD_DEFLATE) return METHOD_DEFLATE;
+  return formatFail(`\u4E0D\u652F\u6301\u7684\u538B\u7F29\u65B9\u6CD5 ${String(value)}\uFF0C\u6761\u76EE "${name}"`, label);
+}
+function hasZip64Extra(view, offset, length) {
+  let cursor = offset;
+  const end = offset + length;
+  while (cursor + 4 <= end) {
+    if (view.getUint16(cursor, true) === ZIP64_EXTRA_ID) return true;
+    cursor += 4 + view.getUint16(cursor + 2, true);
+  }
+  return false;
+}
+function canonicalEntryName(rawName, label) {
+  return chunkIIV6VIUJ_cjs.normalizeArchivePath(rawName, { source: label, label: "\u6761\u76EE\u540D" });
+}
+function lookupKey(name) {
+  try {
+    return chunkIIV6VIUJ_cjs.normalizeArchivePath(name);
+  } catch {
+    return void 0;
+  }
+}
+function findEocd(view, length, label) {
+  if (length < EOCD_SIZE) fail("\u6587\u4EF6\u8FC7\u5C0F\uFF0C\u4E0D\u53EF\u80FD\u662F ZIP", length, label);
+  const floor = Math.max(0, length - EOCD_SIZE - EOCD_MAX_COMMENT);
+  for (let index = length - EOCD_SIZE; index >= floor; index -= 1) {
+    if (view.getUint32(index, true) !== SIGNATURE_EOCD) continue;
+    const commentLength = view.getUint16(index + 20, true);
+    if (index + EOCD_SIZE + commentLength === length) return index;
+  }
+  return fail("\u672A\u627E\u5230 EOCD \u8BB0\u5F55", length, label);
+}
+function readCentralDirectory(bytes, view, eocd, label) {
+  const totalEntries = view.getUint16(eocd + 10, true);
+  const centralSize = view.getUint32(eocd + 12, true);
+  const centralOffset = view.getUint32(eocd + 16, true);
+  if (totalEntries === SENTINEL_16 || centralSize === SENTINEL_32 || centralOffset === SENTINEL_32) {
+    return formatFail("\u5F52\u6863\u4E3A ZIP64\uFF0C\u4E0D\u53D7\u652F\u6301", label);
+  }
+  if (centralOffset + centralSize > eocd) {
+    fail("\u4E2D\u592E\u76EE\u5F55\u8303\u56F4\u8D8A\u754C", centralOffset, label);
+  }
+  const records = [];
+  const foldedFrom = /* @__PURE__ */ new Map();
+  let cursor = centralOffset;
+  for (let index = 0; index < totalEntries; index += 1) {
+    if (cursor + CENTRAL_HEADER_SIZE > bytes.length) fail("\u4E2D\u592E\u76EE\u5F55\u88AB\u622A\u65AD", cursor, label);
+    if (view.getUint32(cursor, true) !== SIGNATURE_CENTRAL) {
+      fail("\u4E2D\u592E\u76EE\u5F55\u5934\u7B7E\u540D\u65E0\u6548", cursor, label);
+    }
+    const flags = view.getUint16(cursor + 8, true);
+    const rawMethod = view.getUint16(cursor + 10, true);
+    const crc = view.getUint32(cursor + 16, true);
+    const compressedSize = view.getUint32(cursor + 20, true);
+    const uncompressedSize = view.getUint32(cursor + 24, true);
+    const nameLength = view.getUint16(cursor + 28, true);
+    const extraLength = view.getUint16(cursor + 30, true);
+    const commentLength = view.getUint16(cursor + 32, true);
+    const localOffset = view.getUint32(cursor + 42, true);
+    const nameStart = cursor + CENTRAL_HEADER_SIZE;
+    const nameEnd = nameStart + nameLength;
+    if (nameEnd > bytes.length) fail("\u6761\u76EE\u540D\u8D8A\u754C", nameStart, label);
+    if (nameEnd + extraLength + commentLength > bytes.length) {
+      fail("\u4E2D\u592E\u76EE\u5F55\u8BB0\u5F55\u957F\u5EA6\u8D8A\u754C", cursor, label);
+    }
+    const rawName = textDecoder.decode(bytes.subarray(nameStart, nameEnd)).replace(/\\/g, "/");
+    const isDirectory = rawName.endsWith("/");
+    const canonical = canonicalEntryName(rawName, label);
+    const previous = foldedFrom.get(canonical);
+    if (previous !== void 0 && previous !== rawName) {
+      throw new chunkG7DLWGBW_cjs.FormatError(
+        `\u6761\u76EE\u540D\u5F52\u4E00\u5316\u540E\u6B67\u4E49\uFF1A"${previous}" \u4E0E "${rawName}" \u90FD\u6307\u5411 "${canonical}"\uFF08\u6E90: ${label}\uFF09`
+      );
+    }
+    foldedFrom.set(canonical, rawName);
+    const name = isDirectory ? `${canonical}/` : canonical;
+    if ((flags & FLAG_ENCRYPTED) !== 0) {
+      formatFail(`\u6761\u76EE "${name}" \u5DF2\u52A0\u5BC6`, label);
+    }
+    if (hasZip64Extra(view, nameEnd, extraLength)) {
+      formatFail(`\u6761\u76EE "${name}" \u4F7F\u7528 ZIP64 \u6269\u5C55\u4FE1\u606F`, label);
+    }
+    records.push({
+      entry: {
+        name,
+        method: toMethod(rawMethod, name, label),
+        compressedSize,
+        uncompressedSize,
+        crc32: crc,
+        isDirectory
+      },
+      localOffset
+    });
+    cursor = nameEnd + extraLength + commentLength;
+  }
+  return records;
+}
+async function readEntry(bytes, record, label, maxEntrySizeBytes) {
+  const { entry, localOffset } = record;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (localOffset + LOCAL_HEADER_SIZE > bytes.length) fail("local header \u8D8A\u754C", localOffset, label);
+  if (view.getUint32(localOffset, true) !== SIGNATURE_LOCAL) {
+    fail("local header \u7B7E\u540D\u65E0\u6548", localOffset, label);
+  }
+  if (entry.method === METHOD_DEFLATE && entry.uncompressedSize > maxEntrySizeBytes) {
+    fail(
+      `\u6761\u76EE "${entry.name}" \u58F0\u660E\u7684\u89E3\u538B\u5C3A\u5BF8 ${String(entry.uncompressedSize)} \u5B57\u8282\u8D85\u8FC7\u4E0A\u9650 ${String(maxEntrySizeBytes)} \u5B57\u8282`,
+      localOffset,
+      label
+    );
+  }
+  const nameLength = view.getUint16(localOffset + 26, true);
+  const extraLength = view.getUint16(localOffset + 28, true);
+  const dataStart = localOffset + LOCAL_HEADER_SIZE + nameLength + extraLength;
+  const dataEnd = dataStart + entry.compressedSize;
+  if (dataEnd > bytes.length) fail("\u6761\u76EE\u6570\u636E\u8D8A\u754C", dataStart, label);
+  const compressed = bytes.subarray(dataStart, dataEnd);
+  const raw = entry.method === METHOD_STORED ? compressed : await inflateRaw(compressed, label, maxEntrySizeBytes);
+  if (raw.length !== entry.uncompressedSize) {
+    fail(
+      `\u6761\u76EE "${entry.name}" \u957F\u5EA6\u4E0D\u7B26\uFF1A\u671F\u671B ${String(entry.uncompressedSize)}\uFF0C\u5B9E\u9645 ${String(raw.length)}`,
+      dataStart,
+      label
+    );
+  }
+  const actualCrc = crc32(raw);
+  if (actualCrc !== entry.crc32) {
+    fail(
+      `\u6761\u76EE "${entry.name}" CRC-32 \u6821\u9A8C\u5931\u8D25\uFF1A\u671F\u671B ${String(entry.crc32)}\uFF0C\u5B9E\u9645 ${String(actualCrc)}`,
+      dataStart,
+      label
+    );
+  }
+  return entry.method === METHOD_STORED ? new Uint8Array(raw) : raw;
+}
+function createArchive(bytes, records, label, maxEntrySizeBytes) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const record of records) byKey.set(chunkIIV6VIUJ_cjs.normalizeArchivePath(record.entry.name), record);
+  const find = (name) => {
+    const key = lookupKey(name);
+    return key === void 0 ? void 0 : byKey.get(key);
+  };
+  const archive = {
+    entries: records.map((record) => record.entry),
+    entry(name) {
+      return find(name)?.entry;
+    },
+    async read(name, options) {
+      chunkG7DLWGBW_cjs.throwIfAborted(options?.signal);
+      const record = find(name);
+      if (record === void 0) formatFail(`\u6761\u76EE\u4E0D\u5B58\u5728 "${name}"`, label);
+      if (record.entry.isDirectory) formatFail(`\u6761\u76EE "${name}" \u662F\u76EE\u5F55\uFF0C\u65E0\u5185\u5BB9`, label);
+      const data = await readEntry(bytes, record, label, maxEntrySizeBytes);
+      return data;
+    },
+    async readText(name, options) {
+      const data = await archive.read(name, options);
+      return textDecoder.decode(data);
+    }
+  };
+  return archive;
+}
+function parseZip(bytes, options) {
+  const label = options?.source ?? "<anonymous>";
+  const maxEntrySizeBytes = options?.maxEntrySizeBytes ?? DEFAULT_MAX_ENTRY_SIZE_BYTES;
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  const eocd = findEocd(view, bytes.length, label);
+  const records = readCentralDirectory(bytes, view, eocd, label);
+  return createArchive(bytes, records, label, maxEntrySizeBytes);
+}
+
+exports.parseZip = parseZip;