frond-js 0.4.0

package/dist/chunk-U4264IQH.js

@@ -0,0 +1,78 @@
+import { FormatError } from './chunk-B2L2YVXD.js';
+
+// src/core/archive-path.ts
+var DEFAULT_LABEL = "\u5F52\u6863\u8DEF\u5F84";
+var UNKNOWN_SOURCE = "<unknown>";
+function formatError(suffix, options) {
+  const label = options.label ?? DEFAULT_LABEL;
+  const source = options.source ?? UNKNOWN_SOURCE;
+  return new FormatError(`${label}${suffix}\uFF08\u6E90: ${source}\uFF09`);
+}
+function hasControlCharacter(value) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code <= 31 || code === 127) return true;
+  }
+  return false;
+}
+function namesNoEntry(value) {
+  for (const segment of value.replace(/\\/g, "/").split("/")) {
+    if (segment !== "" && segment !== "." && segment !== "..") return false;
+  }
+  return true;
+}
+var SCHEME_PATTERN = /^[a-zA-Z][a-zA-Z0-9+.-]*:/;
+function classifyReference(rawValue) {
+  const value = rawValue.trim();
+  if (value === "") return "empty";
+  if (value.startsWith("#")) return "fragment";
+  if (value.startsWith("//")) return "protocol-relative";
+  if (SCHEME_PATTERN.test(value)) return "absolute";
+  return "archive";
+}
+function normalizeArchivePath(rawPath, options = {}) {
+  if (rawPath === "") {
+    throw formatError(" \u4E3A\u7A7A", options);
+  }
+  if (hasControlCharacter(rawPath)) {
+    throw formatError(" \u542B\u63A7\u5236\u5B57\u7B26", options);
+  }
+  const segments = [];
+  for (const segment of rawPath.replace(/\\/g, "/").split("/")) {
+    if (segment === "" || segment === ".") continue;
+    if (segment === "..") {
+      if (segments.length === 0) {
+        throw formatError(` \u8D8A\u51FA\u5F52\u6863\u6839\u76EE\u5F55\uFF1A"${rawPath}"`, options);
+      }
+      segments.pop();
+      continue;
+    }
+    segments.push(segment);
+  }
+  if (segments.length === 0) {
+    throw formatError(` \u89C4\u8303\u5316\u540E\u4E3A\u7A7A\uFF1A"${rawPath}"`, options);
+  }
+  return segments.join("/");
+}
+function resolveArchivePath(basePath, href, options = {}) {
+  if (namesNoEntry(href)) {
+    throw formatError(` \u672A\u6307\u5411\u4EFB\u4F55\u6761\u76EE\uFF1A"${href}"`, options);
+  }
+  const kind = classifyReference(href);
+  if (kind !== "archive") {
+    throw formatError(
+      ` \u4E0D\u662F\u76F8\u5BF9\u5F15\u7528\uFF1A"${href.trim()}"\uFF08\u5E26 scheme\u3001\u534F\u8BAE\u76F8\u5BF9 // \u6216\u7EAF fragment \u90FD\u4E0D\u6307\u5411\u5F52\u6863\u5185\u7684\u6761\u76EE\uFF09`,
+      options
+    );
+  }
+  if (href.startsWith("/")) {
+    return normalizeArchivePath(href, options);
+  }
+  return normalizeArchivePath(basePath === "" ? href : `${basePath}/${href}`, options);
+}
+function directoryOf(archivePath) {
+  const index = archivePath.lastIndexOf("/");
+  return index === -1 ? "" : archivePath.slice(0, index);
+}
+
+export { classifyReference, directoryOf, normalizeArchivePath, resolveArchivePath };

package/dist/chunk-UY2YRCFC.js

@@ -0,0 +1,250 @@
+import { normalizeArchivePath } from './chunk-U4264IQH.js';
+import { FormatError, ParseError, throwIfAborted, isFrondError } from './chunk-B2L2YVXD.js';
+
+// 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 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 (isFrondError(error)) throw error;
+    throw new 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 ParseError(`ZIP \u89E3\u6790\u5931\u8D25\uFF1A${reason}\uFF08\u6E90: ${label}\uFF0C\u504F\u79FB ${String(offset)}\uFF09`);
+}
+function formatFail(reason, label) {
+  throw new 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 normalizeArchivePath(rawName, { source: label, label: "\u6761\u76EE\u540D" });
+}
+function lookupKey(name) {
+  try {
+    return 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 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(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) {
+      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);
+}
+
+export { parseZip };

package/dist/chunk-WCZTTQ7Z.cjs

@@ -0,0 +1,32 @@
+'use strict';
+
+var chunkG7DLWGBW_cjs = require('./chunk-G7DLWGBW.cjs');
+
+// src/core/formats/bytes.ts
+function isBookBytes(value) {
+  return ArrayBuffer.isView(value);
+}
+async function resolveBookBytes(source, options = {}) {
+  if (isBookBytes(source)) return source;
+  const label = options.source ?? "<anonymous>";
+  const { size } = source;
+  if (size === null) {
+    throw new chunkG7DLWGBW_cjs.FormatError(
+      `\u65E0\u6CD5\u6253\u5F00\u4E66\u7C4D\uFF1A\u5B57\u8282\u6E90\u672A\u63D0\u4F9B\u603B\u957F\uFF08size \u4E3A null\uFF09\uFF0C\u4E00\u6B21\u6027\u8BFB\u53D6\u9700\u8981\u5DF2\u77E5\u957F\u5EA6\uFF08\u6E90: ${label}\uFF09`
+    );
+  }
+  if (!Number.isInteger(size) || size < 0) {
+    throw new chunkG7DLWGBW_cjs.FormatError(
+      `\u65E0\u6CD5\u6253\u5F00\u4E66\u7C4D\uFF1A\u5B57\u8282\u6E90\u62A5\u544A\u7684\u603B\u957F\u975E\u6CD5\uFF08size = ${String(size)}\uFF09\uFF08\u6E90: ${label}\uFF09`
+    );
+  }
+  const bytes = await source.read({ start: 0, end: size }, options);
+  if (bytes.byteLength !== size) {
+    throw new chunkG7DLWGBW_cjs.FormatError(
+      `\u65E0\u6CD5\u6253\u5F00\u4E66\u7C4D\uFF1A\u5B57\u8282\u6E90\u8FD4\u56DE ${String(bytes.byteLength)} \u5B57\u8282\uFF0C\u4E0E\u62A5\u544A\u7684\u603B\u957F ${String(size)} \u4E0D\u7B26\uFF08\u6E90: ${label}\uFF09`
+    );
+  }
+  return bytes;
+}
+
+exports.resolveBookBytes = resolveBookBytes;

package/dist/core/index.cjs

@@ -0,0 +1,162 @@
+'use strict';
+
+var chunkGTGLDLJD_cjs = require('../chunk-GTGLDLJD.cjs');
+var chunkNABYHI6X_cjs = require('../chunk-NABYHI6X.cjs');
+var chunkSLI2YL25_cjs = require('../chunk-SLI2YL25.cjs');
+var chunkIIV6VIUJ_cjs = require('../chunk-IIV6VIUJ.cjs');
+var chunkG7DLWGBW_cjs = require('../chunk-G7DLWGBW.cjs');
+
+// src/core/io.ts
+function assertRange(start, end, size, label) {
+  if (!Number.isInteger(start) || !Number.isInteger(end)) {
+    throw new chunkG7DLWGBW_cjs.FormatError(
+      `\u8BFB\u53D6\u533A\u95F4\u5FC5\u987B\u662F\u6574\u6570\uFF1A\u6536\u5230 [${String(start)}, ${String(end)})\uFF08\u6E90: ${label}\uFF09`
+    );
+  }
+  if (start < 0) {
+    throw new chunkG7DLWGBW_cjs.FormatError(`\u8BFB\u53D6\u8D77\u70B9\u4E3A\u8D1F\uFF1A${String(start)}\uFF08\u6E90: ${label}\uFF09`);
+  }
+  if (end > size) {
+    throw new chunkG7DLWGBW_cjs.FormatError(
+      `\u8BFB\u53D6\u7EC8\u70B9\u8D8A\u754C\uFF1A${String(end)} \u8D85\u51FA\u5B57\u8282\u6E90\u603B\u957F ${String(size)}\uFF08\u6E90: ${label}\uFF09`
+    );
+  }
+  if (start > end) {
+    throw new chunkG7DLWGBW_cjs.FormatError(`\u8BFB\u53D6\u533A\u95F4\u8D77\u6B62\u5012\u7F6E\uFF1A[${String(start)}, ${String(end)})\uFF08\u6E90: ${label}\uFF09`);
+  }
+}
+function createMemoryBookSource(bytes, options = {}) {
+  const label = options.source ?? "<anonymous>";
+  const size = bytes.byteLength;
+  let closed = false;
+  return {
+    size,
+    read(range, readOptions) {
+      return Promise.resolve().then(() => {
+        chunkG7DLWGBW_cjs.throwIfAborted(readOptions?.signal);
+        if (closed) {
+          throw new chunkG7DLWGBW_cjs.StateError(`\u5B57\u8282\u6E90\u5DF2\u5173\u95ED\uFF0C\u65E0\u6CD5\u8BFB\u53D6\uFF08\u6E90: ${label}\uFF09`);
+        }
+        assertRange(range.start, range.end, size, label);
+        return bytes.subarray(range.start, range.end);
+      });
+    },
+    close() {
+      closed = true;
+    }
+  };
+}
+
+Object.defineProperty(exports, "collapseCfi", {
+  enumerable: true,
+  get: function () { return chunkGTGLDLJD_cjs.collapseCfi; }
+});
+Object.defineProperty(exports, "isCfi", {
+  enumerable: true,
+  get: function () { return chunkGTGLDLJD_cjs.isCfi; }
+});
+Object.defineProperty(exports, "isCfiString", {
+  enumerable: true,
+  get: function () { return chunkGTGLDLJD_cjs.isCfiString; }
+});
+Object.defineProperty(exports, "parseCfi", {
+  enumerable: true,
+  get: function () { return chunkGTGLDLJD_cjs.parseCfi; }
+});
+Object.defineProperty(exports, "serializeCfi", {
+  enumerable: true,
+  get: function () { return chunkGTGLDLJD_cjs.serializeCfi; }
+});
+Object.defineProperty(exports, "findAll", {
+  enumerable: true,
+  get: function () { return chunkNABYHI6X_cjs.findAll; }
+});
+Object.defineProperty(exports, "findFirst", {
+  enumerable: true,
+  get: function () { return chunkNABYHI6X_cjs.findFirst; }
+});
+Object.defineProperty(exports, "getAttribute", {
+  enumerable: true,
+  get: function () { return chunkNABYHI6X_cjs.getAttribute; }
+});
+Object.defineProperty(exports, "getText", {
+  enumerable: true,
+  get: function () { return chunkNABYHI6X_cjs.getText; }
+});
+Object.defineProperty(exports, "isElement", {
+  enumerable: true,
+  get: function () { return chunkNABYHI6X_cjs.isElement; }
+});
+Object.defineProperty(exports, "parseXml", {
+  enumerable: true,
+  get: function () { return chunkNABYHI6X_cjs.parseXml; }
+});
+Object.defineProperty(exports, "parseZip", {
+  enumerable: true,
+  get: function () { return chunkSLI2YL25_cjs.parseZip; }
+});
+Object.defineProperty(exports, "directoryOf", {
+  enumerable: true,
+  get: function () { return chunkIIV6VIUJ_cjs.directoryOf; }
+});
+Object.defineProperty(exports, "normalizeArchivePath", {
+  enumerable: true,
+  get: function () { return chunkIIV6VIUJ_cjs.normalizeArchivePath; }
+});
+Object.defineProperty(exports, "resolveArchivePath", {
+  enumerable: true,
+  get: function () { return chunkIIV6VIUJ_cjs.resolveArchivePath; }
+});
+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.createMemoryBookSource = createMemoryBookSource;