frond-js 0.4.0

package/dist/chunk-GTGLDLJD.cjs

@@ -0,0 +1,479 @@
+'use strict';
+
+var chunkG7DLWGBW_cjs = require('./chunk-G7DLWGBW.cjs');
+
+// src/core/cfi/serialize.ts
+var ESCAPABLE = "^[](),;=";
+function escapeValue(value) {
+  let out = "";
+  for (const char of value) {
+    out += ESCAPABLE.includes(char) ? `^${char}` : char;
+  }
+  return out;
+}
+function serializeSide(side) {
+  if (side === void 0) return "";
+  return `;s=${side === "before" ? "b" : "a"}`;
+}
+function wrapAssertion(body) {
+  return body === "" ? "" : `[${body}]`;
+}
+function serializeStep(step) {
+  const body = `${step.id === void 0 ? "" : escapeValue(step.id)}${serializeSide(step.side)}`;
+  return `/${step.index}${wrapAssertion(body)}`;
+}
+function serializeOffset(offset, point) {
+  if (offset === void 0) {
+    if (point.text === void 0 && point.textAfter === void 0 && point.side === void 0) {
+      return "";
+    }
+    throw new chunkG7DLWGBW_cjs.FormatError("\u504F\u79FB\u65AD\u8A00\u7F3A\u5C11\u5B57\u7B26\u504F\u79FB");
+  }
+  const values = point.text === void 0 ? point.textAfter === void 0 ? "" : `,${escapeValue(point.textAfter)}` : `${escapeValue(point.text)}${point.textAfter === void 0 ? "" : `,${escapeValue(point.textAfter)}`}`;
+  return `:${offset}${wrapAssertion(`${values}${serializeSide(point.side)}`)}`;
+}
+function serializeSteps(steps) {
+  return steps.map(serializeStep).join("");
+}
+function serializePaths(paths) {
+  return paths.map((path) => serializeSteps(path.steps)).join("!");
+}
+function serializePointBody(point) {
+  return `${serializePaths(point.paths)}${serializeOffset(point.offset, point)}`;
+}
+function serializePoint(point) {
+  return `epubcfi(${serializePointBody(point)})`;
+}
+function relativeSubpath(parent, point, label) {
+  const parentLength = parent.length;
+  const mismatch = new chunkG7DLWGBW_cjs.FormatError(`${label} \u4E0E\u7236\u8DEF\u5F84\u7ED3\u6784\u4E0D\u4E00\u81F4\uFF0C\u65E0\u6CD5\u56DE\u5199\u4E3A\u89C4\u8303\u5F62\u6001`);
+  if (parentLength === 0 || point.paths.length < parentLength) throw mismatch;
+  const sameSteps = (left, right) => {
+    if (left.length !== right.length) return false;
+    return left.every((step, index) => step.index === right[index]?.index);
+  };
+  for (let i = 0; i < parentLength - 1; i += 1) {
+    const expected = parent[i];
+    const actual = point.paths[i];
+    if (expected === void 0 || actual === void 0 || !sameSteps(expected.steps, actual.steps)) {
+      throw mismatch;
+    }
+  }
+  const parentLast = parent[parentLength - 1];
+  const merged = point.paths[parentLength - 1];
+  if (parentLast === void 0 || merged === void 0) throw mismatch;
+  const prefix = parentLast.steps;
+  if (merged.steps.length < prefix.length) throw mismatch;
+  for (let i = 0; i < prefix.length; i += 1) {
+    if (prefix[i]?.index !== merged.steps[i]?.index) throw mismatch;
+  }
+  let body = serializeSteps(merged.steps.slice(prefix.length));
+  for (const path of point.paths.slice(parentLength)) {
+    body += `!${serializeSteps(path.steps)}`;
+  }
+  return `${body}${serializeOffset(point.offset, point)}`;
+}
+function serializeRange(range) {
+  if (range.parent === null) {
+    return `epubcfi(${serializePointBody(range.start)},${serializePointBody(range.end)})`;
+  }
+  const parentBody = serializePaths(range.parent);
+  const startBody = relativeSubpath(range.parent, range.start, "\u8303\u56F4\u8D77\u70B9");
+  const endBody = relativeSubpath(range.parent, range.end, "\u8303\u56F4\u7EC8\u70B9");
+  return `epubcfi(${parentBody},${startBody},${endBody})`;
+}
+function serializeCfi(cfi) {
+  return cfi.kind === "point" ? serializePoint(cfi) : serializeRange(cfi);
+}
+
+// src/core/cfi/collapse.ts
+function collapseCfi(cfi, toEnd = false) {
+  if (cfi.kind === "point") return serializePoint(cfi);
+  return serializePoint(toEnd ? cfi.end : cfi.start);
+}
+
+// src/core/cfi/parse.ts
+var ESCAPABLE2 = "^[](),;=";
+function isDigit(char) {
+  return char !== void 0 && char >= "0" && char <= "9";
+}
+function splitTopLevel(raw, separator, context) {
+  const parts = [];
+  let current = "";
+  let depth = 0;
+  for (let i = 0; i < raw.length; i += 1) {
+    const char = raw[i];
+    if (char === "^") {
+      const next = raw[i + 1];
+      if (next === void 0) {
+        throw new chunkG7DLWGBW_cjs.ParseError(`\u8F6C\u4E49\u7B26 '^' \u540E\u7F3A\u5C11\u5B57\u7B26\uFF08${context}\uFF09`);
+      }
+      current += char + next;
+      i += 1;
+      continue;
+    }
+    if (char === "[") {
+      depth += 1;
+      current += char;
+      continue;
+    }
+    if (char === "]") {
+      depth -= 1;
+      if (depth < 0) {
+        throw new chunkG7DLWGBW_cjs.ParseError(`\u51FA\u73B0\u672A\u914D\u5BF9\u7684 ']'\uFF08${context}\uFF09`);
+      }
+      current += char;
+      continue;
+    }
+    if (char === separator && depth === 0) {
+      parts.push(current);
+      current = "";
+      continue;
+    }
+    current += char;
+  }
+  if (depth !== 0) {
+    throw new chunkG7DLWGBW_cjs.ParseError(`\u65B9\u62EC\u53F7\u672A\u95ED\u5408\uFF08${context}\uFF09`);
+  }
+  parts.push(current);
+  return parts;
+}
+function unescapeValue(raw, context) {
+  let out = "";
+  for (let i = 0; i < raw.length; i += 1) {
+    const char = raw[i];
+    if (char !== "^") {
+      out += char;
+      continue;
+    }
+    const next = raw[i + 1];
+    if (next === void 0) {
+      throw new chunkG7DLWGBW_cjs.ParseError(`\u65AD\u8A00\u4E2D\u5B58\u5728\u672A\u5B8C\u6210\u7684\u8F6C\u4E49\u7B26 '^'\uFF08${context}\uFF09`);
+    }
+    if (!ESCAPABLE2.includes(next)) {
+      throw new chunkG7DLWGBW_cjs.FormatError(`\u65AD\u8A00\u4E2D\u7684\u8F6C\u4E49\u5B57\u7B26\u975E\u6CD5\uFF1A'^${next}'\uFF08${context}\uFF09`);
+    }
+    out += next;
+    i += 1;
+  }
+  return out;
+}
+function containsUnescapedOpenBracket(raw) {
+  for (let i = 0; i < raw.length; i += 1) {
+    const char = raw[i];
+    if (char === "^") {
+      i += 1;
+      continue;
+    }
+    if (char === "[") return true;
+  }
+  return false;
+}
+function parseAssertion(raw, context) {
+  if (containsUnescapedOpenBracket(raw)) {
+    throw new chunkG7DLWGBW_cjs.FormatError(`\u65AD\u8A00\u4E2D\u7684 '[' \u5FC5\u987B\u8F6C\u4E49\u4E3A '^['\uFF08${context}\uFF09`);
+  }
+  const [valuePart = "", ...parameters] = splitTopLevel(raw, ";", context);
+  let leading;
+  let trailing;
+  if (valuePart !== "") {
+    const values = splitTopLevel(valuePart, ",", context);
+    if (values.length > 2) {
+      throw new chunkG7DLWGBW_cjs.FormatError(`\u65AD\u8A00\u4E2D\u9017\u53F7\u5206\u9694\u7684\u503C\u8D85\u8FC7 2 \u4E2A\uFF08${context}\uFF09`);
+    }
+    const [first = "", second] = values;
+    if (first !== "") {
+      leading = unescapeValue(first, context);
+    }
+    if (second !== void 0 && second !== "") {
+      trailing = unescapeValue(second, context);
+    }
+  }
+  let side;
+  for (const parameter of parameters) {
+    const equal = parameter.indexOf("=");
+    if (equal <= 0) {
+      throw new chunkG7DLWGBW_cjs.FormatError(`\u65AD\u8A00\u53C2\u6570\u7F3A\u5C11 'k=v' \u5F62\u5F0F\uFF1A${JSON.stringify(parameter)}\uFF08${context}\uFF09`);
+    }
+    const name = parameter.slice(0, equal);
+    const value = parameter.slice(equal + 1);
+    if (name !== "s") {
+      throw new chunkG7DLWGBW_cjs.FormatError(
+        `\u65AD\u8A00\u53C2\u6570\u540D\u4E0D\u652F\u6301\uFF1A${JSON.stringify(name)}\uFF08\u4EC5\u652F\u6301 's'\uFF09\uFF08${context}\uFF09`
+      );
+    }
+    if (value === "b") {
+      side = "before";
+    } else if (value === "a") {
+      side = "after";
+    } else {
+      throw new chunkG7DLWGBW_cjs.FormatError(
+        `side bias \u53D6\u503C\u975E\u6CD5\uFF1A${JSON.stringify(value)}\uFF08\u4EC5\u652F\u6301 'b' / 'a'\uFF09\uFF08${context}\uFF09`
+      );
+    }
+  }
+  return {
+    ...leading !== void 0 ? { leading } : {},
+    ...trailing !== void 0 ? { trailing } : {},
+    ...side !== void 0 ? { side } : {}
+  };
+}
+function tryReadAssertion(raw, start, context) {
+  if (raw[start] !== "[") return null;
+  let depth = 0;
+  for (let i = start; i < raw.length; i += 1) {
+    const char = raw[i];
+    if (char === "^") {
+      i += 1;
+      continue;
+    }
+    if (char === "[") {
+      depth += 1;
+    } else if (char === "]") {
+      depth -= 1;
+      if (depth === 0) {
+        return { content: raw.slice(start + 1, i), next: i + 1 };
+      }
+    }
+  }
+  throw new chunkG7DLWGBW_cjs.ParseError(`\u65B9\u62EC\u53F7\u672A\u95ED\u5408\uFF08${context}\uFF09`);
+}
+function parseInteger(raw, context) {
+  if (raw.length > 1 && raw.startsWith("0")) {
+    throw new chunkG7DLWGBW_cjs.ParseError(`\u6570\u5B57\u4E0D\u5141\u8BB8\u524D\u5BFC\u96F6\uFF1A${JSON.stringify(raw)}\uFF08${context}\uFF09`);
+  }
+  const value = Number(raw);
+  if (!Number.isSafeInteger(value)) {
+    throw new chunkG7DLWGBW_cjs.ParseError(`\u6570\u5B57\u8D85\u51FA\u5B89\u5168\u6574\u6570\u8303\u56F4\uFF1A${JSON.stringify(raw)}\uFF08${context}\uFF09`);
+  }
+  return value;
+}
+function parseSegment(raw, context) {
+  const steps = [];
+  let offset;
+  let assertion;
+  let index = 0;
+  while (index < raw.length) {
+    const char = raw[index];
+    if (char === "/") {
+      if (offset !== void 0) {
+        throw new chunkG7DLWGBW_cjs.ParseError(`\u5B57\u7B26\u504F\u79FB\u4E4B\u540E\u4E0D\u5141\u8BB8\u518D\u51FA\u73B0\u6B65\u9AA4\uFF08${context}\uFF09`);
+      }
+      index += 1;
+      const digitsStart = index;
+      while (isDigit(raw[index])) index += 1;
+      if (index === digitsStart) {
+        throw new chunkG7DLWGBW_cjs.ParseError(`\u6B65\u9AA4\u7F3A\u5C11\u7D22\u5F15\u6570\u5B57\uFF08${context}\uFF09`);
+      }
+      const stepIndex = parseInteger(raw.slice(digitsStart, index), context);
+      const scanned = tryReadAssertion(raw, index, context);
+      let step = { index: stepIndex };
+      if (scanned !== null) {
+        index = scanned.next;
+        const parsed = parseAssertion(scanned.content, context);
+        if (parsed.trailing !== void 0) {
+          throw new chunkG7DLWGBW_cjs.FormatError(`\u6B65\u9AA4\u4E0A\u7684\u65AD\u8A00\u4E0D\u63A5\u53D7\u9017\u53F7\u5206\u9694\u7684\u7B2C\u4E8C\u4E2A\u503C\uFF08${context}\uFF09`);
+        }
+        step = {
+          index: stepIndex,
+          ...parsed.leading !== void 0 ? { id: parsed.leading } : {},
+          ...parsed.side !== void 0 ? { side: parsed.side } : {}
+        };
+      }
+      steps.push(step);
+      continue;
+    }
+    if (char === ":") {
+      if (offset !== void 0) {
+        throw new chunkG7DLWGBW_cjs.ParseError(`\u8DEF\u5F84\u4E2D\u51FA\u73B0\u91CD\u590D\u7684\u5B57\u7B26\u504F\u79FB\uFF08${context}\uFF09`);
+      }
+      index += 1;
+      const digitsStart = index;
+      while (isDigit(raw[index])) index += 1;
+      if (index === digitsStart) {
+        throw new chunkG7DLWGBW_cjs.ParseError(`\u5B57\u7B26\u504F\u79FB\u7F3A\u5C11\u6570\u5B57\uFF08${context}\uFF09`);
+      }
+      offset = parseInteger(raw.slice(digitsStart, index), context);
+      const scanned = tryReadAssertion(raw, index, context);
+      if (scanned !== null) {
+        index = scanned.next;
+        assertion = parseAssertion(scanned.content, context);
+      }
+      continue;
+    }
+    throw new chunkG7DLWGBW_cjs.ParseError(`\u8DEF\u5F84\u4E2D\u51FA\u73B0\u65E0\u6CD5\u8BC6\u522B\u7684\u5B57\u7B26 ${JSON.stringify(char)}\uFF08${context}\uFF09`);
+  }
+  if (steps.length === 0) {
+    throw new chunkG7DLWGBW_cjs.ParseError(`\u8DEF\u5F84\u6BB5\u7F3A\u5C11\u6B65\u9AA4\uFF08${context}\uFF09`);
+  }
+  return {
+    paths: [{ steps }],
+    ...offset !== void 0 ? { offset } : {},
+    ...assertion !== void 0 ? { assertion } : {}
+  };
+}
+function parsePath(raw, context) {
+  if (raw === "") {
+    throw new chunkG7DLWGBW_cjs.ParseError(`\u8DEF\u5F84\u4E3A\u7A7A\uFF08${context}\uFF09`);
+  }
+  const segments = splitTopLevel(raw, "!", context);
+  const paths = [];
+  let offset;
+  let assertion;
+  segments.forEach((segment, segmentIndex) => {
+    const isLast = segmentIndex === segments.length - 1;
+    if (segment === "") {
+      throw new chunkG7DLWGBW_cjs.ParseError(`'!' \u4E4B\u540E\u7F3A\u5C11\u8DEF\u5F84\u6BB5\uFF08${context}\uFF09`);
+    }
+    if (!segment.startsWith("/")) {
+      throw new chunkG7DLWGBW_cjs.ParseError(`\u8DEF\u5F84\u6BB5\u5FC5\u987B\u4EE5 '/' \u5F00\u5934\uFF1A${JSON.stringify(segment)}\uFF08${context}\uFF09`);
+    }
+    const parsed = parseSegment(segment, context);
+    if (isLast) {
+      offset = parsed.offset;
+      assertion = parsed.assertion;
+    } else if (parsed.offset !== void 0) {
+      throw new chunkG7DLWGBW_cjs.FormatError(`\u975E\u672B\u6BB5\u4E0D\u5141\u8BB8\u51FA\u73B0\u5B57\u7B26\u504F\u79FB\uFF08${context}\uFF09`);
+    }
+    for (const path of parsed.paths) paths.push(path);
+  });
+  return {
+    paths,
+    ...offset !== void 0 ? { offset } : {},
+    ...assertion !== void 0 ? { assertion } : {}
+  };
+}
+function toPoint(parsed) {
+  const draft = {
+    kind: "point",
+    paths: parsed.paths,
+    ...parsed.offset !== void 0 ? { offset: parsed.offset } : {},
+    ...parsed.assertion?.leading !== void 0 ? { text: parsed.assertion.leading } : {},
+    ...parsed.assertion?.trailing !== void 0 ? { textAfter: parsed.assertion.trailing } : {},
+    ...parsed.assertion?.side !== void 0 ? { side: parsed.assertion.side } : {},
+    value: ""
+  };
+  return { ...draft, value: serializePoint(draft) };
+}
+function concatPath(parent, child, context) {
+  if (parent.offset !== void 0) {
+    throw new chunkG7DLWGBW_cjs.FormatError(`\u8303\u56F4\u7236\u8DEF\u5F84\u4E0D\u5141\u8BB8\u5E26\u5B57\u7B26\u504F\u79FB\uFF08${context}\uFF09`);
+  }
+  const lastIndex = parent.paths.length - 1;
+  const lastPath = parent.paths[lastIndex];
+  const childFirst = child.paths[0];
+  if (lastPath === void 0 || childFirst === void 0) {
+    throw new chunkG7DLWGBW_cjs.ParseError(`\u8303\u56F4\u8DEF\u5F84\u4E3A\u7A7A\uFF08${context}\uFF09`);
+  }
+  const merged = { steps: [...lastPath.steps, ...childFirst.steps] };
+  return {
+    paths: [...parent.paths.slice(0, lastIndex), merged, ...child.paths.slice(1)],
+    ...child.offset !== void 0 ? { offset: child.offset } : {},
+    ...child.assertion !== void 0 ? { assertion: child.assertion } : {}
+  };
+}
+function freezeCfi(cfi) {
+  const freezePaths = (paths) => {
+    for (const path of paths) {
+      for (const step of path.steps) Object.freeze(step);
+      Object.freeze(path.steps);
+      Object.freeze(path);
+    }
+    Object.freeze(paths);
+  };
+  if (cfi.kind === "point") {
+    freezePaths(cfi.paths);
+  } else {
+    freezeCfi(cfi.start);
+    freezeCfi(cfi.end);
+    if (cfi.parent !== null) freezePaths(cfi.parent);
+  }
+  return Object.freeze(cfi);
+}
+function stripWrapper(input, context) {
+  if (input.startsWith("epubcfi(")) {
+    if (!input.endsWith(")")) {
+      throw new chunkG7DLWGBW_cjs.ParseError(`\u7F3A\u5C11\u7ED3\u5C3E\u7684 ')'\uFF08${context}\uFF09`);
+    }
+    return input.slice("epubcfi(".length, -1);
+  }
+  if (input.endsWith(")") && input.includes("(")) {
+    throw new chunkG7DLWGBW_cjs.ParseError(`CFI \u524D\u7F00\u975E\u6CD5\uFF08\u5E94\u4E3A 'epubcfi('\uFF09\uFF1A${JSON.stringify(input)}\uFF08${context}\uFF09`);
+  }
+  return input;
+}
+function parseCfi(input) {
+  const context = `CFI ${JSON.stringify(input)}`;
+  const inner = stripWrapper(input, context);
+  if (inner === "") {
+    throw new chunkG7DLWGBW_cjs.ParseError(`CFI \u5185\u5BB9\u4E3A\u7A7A\uFF08${context}\uFF09`);
+  }
+  const parts = splitTopLevel(inner, ",", context);
+  if (parts.length === 1) {
+    return freezeCfi(toPoint(parsePath(parts[0], context)));
+  }
+  if (parts.length === 2) {
+    const [startRaw, endRaw] = parts;
+    const draft = {
+      kind: "range",
+      start: toPoint(parsePath(startRaw, context)),
+      end: toPoint(parsePath(endRaw, context)),
+      parent: null,
+      value: ""
+    };
+    return freezeCfi({ ...draft, value: serializeCfi(draft) });
+  }
+  if (parts.length === 3) {
+    const [parentRaw, startRaw, endRaw] = parts;
+    const parent = parsePath(parentRaw, context);
+    const startParsed = startRaw === "" ? parent : concatPath(parent, parsePath(startRaw, context), context);
+    const endParsed = endRaw === "" ? parent : concatPath(parent, parsePath(endRaw, context), context);
+    const draft = {
+      kind: "range",
+      start: toPoint(startParsed),
+      end: toPoint(endParsed),
+      parent: parent.paths,
+      value: ""
+    };
+    return freezeCfi({ ...draft, value: serializeCfi(draft) });
+  }
+  throw new chunkG7DLWGBW_cjs.ParseError(`\u8303\u56F4\u6700\u591A\u63A5\u53D7 3 \u4E2A\u9017\u53F7\u5206\u9694\u7684\u90E8\u5206\uFF0C\u5B9E\u9645 ${parts.length} \u4E2A\uFF08${context}\uFF09`);
+}
+
+// src/core/cfi/guards.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function isPathsLike(value) {
+  return Array.isArray(value) && value.every((path) => isRecord(path) && Array.isArray(path["steps"]));
+}
+function isPointLike(value) {
+  if (!isRecord(value)) return false;
+  return value["kind"] === "point" && isPathsLike(value["paths"]) && typeof value["value"] === "string";
+}
+function isRangeLike(value) {
+  if (!isRecord(value)) return false;
+  const parent = value["parent"];
+  return value["kind"] === "range" && isPointLike(value["start"]) && isPointLike(value["end"]) && (parent === null || isPathsLike(parent)) && typeof value["value"] === "string";
+}
+function isCfi(value) {
+  return isPointLike(value) || isRangeLike(value);
+}
+function isCfiString(value) {
+  if (typeof value !== "string") return false;
+  const trimmed = value.trim();
+  if (trimmed === "") return false;
+  if (!(trimmed.startsWith("epubcfi(") || trimmed.startsWith("/"))) return false;
+  try {
+    parseCfi(trimmed);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+exports.collapseCfi = collapseCfi;
+exports.isCfi = isCfi;
+exports.isCfiString = isCfiString;
+exports.parseCfi = parseCfi;
+exports.serializeCfi = serializeCfi;

package/dist/chunk-IIV6VIUJ.cjs

@@ -0,0 +1,83 @@
+'use strict';
+
+var chunkG7DLWGBW_cjs = require('./chunk-G7DLWGBW.cjs');
+
+// 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 chunkG7DLWGBW_cjs.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);
+}
+
+exports.classifyReference = classifyReference;
+exports.directoryOf = directoryOf;
+exports.normalizeArchivePath = normalizeArchivePath;
+exports.resolveArchivePath = resolveArchivePath;

package/dist/chunk-JDTHZQUK.js

@@ -0,0 +1,102 @@
+// src/core/formats/probe.ts
+var PROBE_PREFIX_BYTES = 1024;
+var PDF_MAGIC = "%PDF-";
+var ZIP_MAGIC = [80, 75, 3, 4];
+var MOBI_MARKER = "BOOKMOBI";
+var MOBI_MARKER_OFFSET = 60;
+var XML_DECLARATION = "<?xml";
+var FB2_ROOT = "<FictionBook";
+var UTF8_BOM = [239, 187, 191];
+var EPUB_CONTAINER_ENTRY = "META-INF/container.xml";
+var FB2_EXTENSION = ".fb2";
+var IMAGE_EXTENSIONS = [".jpg", ".jpeg", ".png", ".gif", ".webp", ".avif"];
+function probeFormat(prefix) {
+  if (matchesAscii(prefix, 0, PDF_MAGIC)) {
+    return { kind: "format", format: "pdf", evidence: `%PDF- \u9B54\u6570\uFF08offset 0\uFF09` };
+  }
+  if (matchesBytes(prefix, 0, ZIP_MAGIC)) {
+    return {
+      kind: "container",
+      container: "zip",
+      evidence: "PK\\x03\\x04 \u9B54\u6570\uFF08offset 0\uFF09\u2014\u2014 ZIP \u5BB9\u5668\uFF0C\u9700\u8BFB\u6761\u76EE\u540D\u624D\u80FD\u5B9A\u683C\u5F0F"
+    };
+  }
+  if (matchesAscii(prefix, MOBI_MARKER_OFFSET, MOBI_MARKER)) {
+    return {
+      kind: "format",
+      format: "mobi",
+      evidence: `BOOKMOBI \u6807\u8BB0\uFF08offset ${String(MOBI_MARKER_OFFSET)}\uFF0CPalmDB \u5934\uFF09`
+    };
+  }
+  if (looksLikeFb2(prefix)) {
+    return {
+      kind: "format",
+      format: "fb2",
+      evidence: "XML \u58F0\u660E\u6216 <FictionBook> \u6839\u5143\u7D20 + \u542B <FictionBook>"
+    };
+  }
+  return null;
+}
+function probeZipContainer(names) {
+  const entries = names.filter((name) => !name.endsWith("/"));
+  if (entries.includes(EPUB_CONTAINER_ENTRY)) {
+    return {
+      kind: "format",
+      format: "epub",
+      evidence: `ZIP \u5185\u542B ${EPUB_CONTAINER_ENTRY}\uFF08OCF \u89C4\u8303\u56FA\u5B9A\u4F4D\u7F6E\uFF09`
+    };
+  }
+  if (entries.some((name) => name.toLowerCase().endsWith(FB2_EXTENSION))) {
+    return {
+      kind: "format",
+      format: "fb2",
+      evidence: `ZIP \u5185\u542B ${FB2_EXTENSION} \u4E14\u65E0 ${EPUB_CONTAINER_ENTRY}\uFF08.fb2.zip \u53D8\u4F53\uFF09`
+    };
+  }
+  if (entries.some(
+    (name) => IMAGE_EXTENSIONS.some((extension) => name.toLowerCase().endsWith(extension))
+  )) {
+    return {
+      kind: "format",
+      format: "cbz",
+      evidence: `ZIP \u5185\u53EA\u6709\u56FE\u7247\u6761\u76EE\u4E14\u65E0 ${EPUB_CONTAINER_ENTRY}\uFF08CBZ\uFF09`
+    };
+  }
+  return null;
+}
+function matchesAscii(bytes, offset, text) {
+  if (offset < 0 || offset + text.length > bytes.byteLength) return false;
+  for (let i = 0; i < text.length; i++) {
+    if (bytes[offset + i] !== text.charCodeAt(i)) return false;
+  }
+  return true;
+}
+function matchesBytes(bytes, offset, expected) {
+  if (offset + expected.length > bytes.byteLength) return false;
+  for (let i = 0; i < expected.length; i++) {
+    if (bytes[offset + i] !== expected[i]) return false;
+  }
+  return true;
+}
+function indexOfAscii(bytes, text) {
+  const limit = bytes.byteLength - text.length;
+  for (let start = 0; start <= limit; start++) {
+    if (matchesAscii(bytes, start, text)) return start;
+  }
+  return -1;
+}
+function looksLikeFb2(prefix) {
+  if (indexOfAscii(prefix, FB2_ROOT) === -1) return false;
+  let start = matchesBytes(prefix, 0, UTF8_BOM) ? UTF8_BOM.length : 0;
+  for (; ; ) {
+    const byte = prefix[start];
+    if (byte === void 0 || !isAsciiWhitespace(byte)) break;
+    start++;
+  }
+  return matchesAscii(prefix, start, XML_DECLARATION) || matchesAscii(prefix, start, FB2_ROOT);
+}
+function isAsciiWhitespace(byte) {
+  return byte === 32 || byte === 9 || byte === 13 || byte === 10 || byte === 12 || byte === 11;
+}
+
+export { EPUB_CONTAINER_ENTRY, IMAGE_EXTENSIONS, PROBE_PREFIX_BYTES, probeFormat, probeZipContainer };

package/dist/chunk-JJVXT3AC.js

@@ -0,0 +1,30 @@
+import { FormatError } from './chunk-B2L2YVXD.js';
+
+// 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 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 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 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;
+}
+
+export { resolveBookBytes };