frond-js 0.4.0

package/dist/chunk-LIXRYQL2.js

@@ -0,0 +1,473 @@
+import { ParseError, FormatError } from './chunk-B2L2YVXD.js';
+
+// 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 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 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 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 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 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 ParseError(`\u65AD\u8A00\u4E2D\u5B58\u5728\u672A\u5B8C\u6210\u7684\u8F6C\u4E49\u7B26 '^'\uFF08${context}\uFF09`);
+    }
+    if (!ESCAPABLE2.includes(next)) {
+      throw new 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 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 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 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 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 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 ParseError(`\u65B9\u62EC\u53F7\u672A\u95ED\u5408\uFF08${context}\uFF09`);
+}
+function parseInteger(raw, context) {
+  if (raw.length > 1 && raw.startsWith("0")) {
+    throw new 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 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 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 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 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 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 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 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 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 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 ParseError(`'!' \u4E4B\u540E\u7F3A\u5C11\u8DEF\u5F84\u6BB5\uFF08${context}\uFF09`);
+    }
+    if (!segment.startsWith("/")) {
+      throw new 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 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 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 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 ParseError(`\u7F3A\u5C11\u7ED3\u5C3E\u7684 ')'\uFF08${context}\uFF09`);
+    }
+    return input.slice("epubcfi(".length, -1);
+  }
+  if (input.endsWith(")") && input.includes("(")) {
+    throw new 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 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 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;
+  }
+}
+
+export { collapseCfi, isCfi, isCfiString, parseCfi, serializeCfi };