wiki-graph-core 0.3.1 → 0.4.0

package/dist/evidence-selection/anchor-resolver.js

@@ -1,783 +0,0 @@
-import { normalizeText, splitTextIntoSentences } from "./text.js";
-const MIN_AUTO_RESOLVE_GAP = 0.07;
-const MIN_AUTO_RESOLVE_SCORE = 0.9;
-const MIN_BOUNDARY_BONUS_LENGTH = 12;
-const MIN_CANDIDATE_SCORE = 0.55;
-const VERY_HIGH_CONFIDENCE_SCORE = 0.97;
-const MAX_BOUNDARY_BONUS = 0.08;
-const MAX_CANDIDATE_DISPLAY = 3;
-class EvidenceResolver {
-  resolve(evidence, candidateSentenceIds, candidateTexts) {
-    const startValue = evidence.start_anchor ?? evidence.start;
-    const endValue = evidence.end_anchor ?? evidence.end;
-    const [startAnchor, startFailure] = this.parseAnchor(
-      startValue,
-      "start_anchor"
-    );
-    if (startFailure !== void 0) {
-      return [void 0, startFailure];
-    }
-    let endAnchor;
-    if (endValue !== void 0) {
-      const [parsedEndAnchor, endFailure] = this.parseAnchor(
-        endValue,
-        "end_anchor"
-      );
-      if (endFailure !== void 0) {
-        return [void 0, endFailure];
-      }
-      endAnchor = parsedEndAnchor;
-    }
-    const [startCandidate, startStrategy, startResolveFailure] = this.resolveAnchor({
-      anchor: startAnchor,
-      candidateSentenceIds,
-      candidateTexts,
-      label: "start_anchor"
-    });
-    if (startResolveFailure !== void 0) {
-      return [void 0, startResolveFailure];
-    }
-    if (startCandidate === void 0) {
-      return [
-        void 0,
-        {
-          candidates: [],
-          code: "none",
-          fieldName: "start_anchor",
-          message: "start_anchor could not be matched: no candidate selected"
-        }
-      ];
-    }
-    if (endAnchor === void 0) {
-      return [
-        {
-          confidence: startCandidate.score,
-          sentenceIds: [startCandidate.sentenceId],
-          strategy: startStrategy
-        },
-        void 0
-      ];
-    }
-    const [endCandidate, endStrategy, endResolveFailure] = this.resolveAnchor({
-      anchor: endAnchor,
-      candidateSentenceIds,
-      candidateTexts,
-      label: "end_anchor",
-      minIndex: startCandidate.index
-    });
-    if (endResolveFailure !== void 0) {
-      return [void 0, endResolveFailure];
-    }
-    if (endCandidate === void 0) {
-      return [
-        void 0,
-        {
-          candidates: [],
-          code: "none",
-          fieldName: "end_anchor",
-          message: "end_anchor could not be matched: no candidate selected"
-        }
-      ];
-    }
-    if (endCandidate.index < startCandidate.index) {
-      return [
-        void 0,
-        {
-          candidates: [],
-          code: "invalid_range",
-          fieldName: "end_anchor",
-          message: `Invalid evidence range: end_anchor resolved before start_anchor (${startCandidate.occurrenceId} -> ${endCandidate.occurrenceId}).`
-        }
-      ];
-    }
-    return [
-      {
-        confidence: Math.min(startCandidate.score, endCandidate.score),
-        sentenceIds: candidateSentenceIds.slice(
-          startCandidate.index,
-          endCandidate.index + 1
-        ),
-        strategy: `${startStrategy}+${endStrategy}`
-      },
-      void 0
-    ];
-  }
-  resolveWithOverrides(input) {
-    const startValue = input.evidence.start_anchor ?? input.evidence.start;
-    const endValue = input.evidence.end_anchor ?? input.evidence.end;
-    const [startAnchor, startFailure] = this.parseAnchor(
-      startValue,
-      "start_anchor"
-    );
-    if (startFailure !== void 0) {
-      return [void 0, startFailure];
-    }
-    const startCandidateOverride = input.overrides.start_anchor;
-    const [startCandidate, startStrategy, startResolveFailure] = startCandidateOverride === void 0 ? this.resolveAnchor({
-      anchor: startAnchor,
-      candidateSentenceIds: input.candidateSentenceIds,
-      candidateTexts: input.candidateTexts,
-      label: "start_anchor"
-    }) : [startCandidateOverride, "choice_final", void 0];
-    if (startResolveFailure !== void 0) {
-      return [void 0, startResolveFailure];
-    }
-    if (startCandidate === void 0) {
-      return [
-        void 0,
-        {
-          candidates: [],
-          code: "none",
-          fieldName: "start_anchor",
-          message: "start_anchor could not be matched: no candidate selected"
-        }
-      ];
-    }
-    if (endValue === void 0) {
-      return [
-        {
-          confidence: startCandidate.score,
-          sentenceIds: [startCandidate.sentenceId],
-          strategy: startStrategy
-        },
-        void 0
-      ];
-    }
-    const [endAnchor, endFailure] = this.parseAnchor(endValue, "end_anchor");
-    if (endFailure !== void 0) {
-      return [void 0, endFailure];
-    }
-    const endCandidateOverride = input.overrides.end_anchor;
-    const [endCandidate, endStrategy, endResolveFailure] = endCandidateOverride === void 0 ? this.resolveAnchor({
-      anchor: endAnchor,
-      candidateSentenceIds: input.candidateSentenceIds,
-      candidateTexts: input.candidateTexts,
-      label: "end_anchor",
-      minIndex: startCandidate.index
-    }) : [endCandidateOverride, "choice_final", void 0];
-    if (endResolveFailure !== void 0) {
-      return [void 0, endResolveFailure];
-    }
-    if (endCandidate === void 0) {
-      return [
-        void 0,
-        {
-          candidates: [],
-          code: "none",
-          fieldName: "end_anchor",
-          message: "end_anchor could not be matched: no candidate selected"
-        }
-      ];
-    }
-    if (endCandidate.index < startCandidate.index) {
-      return [
-        void 0,
-        {
-          candidates: [],
-          code: "invalid_range",
-          fieldName: "end_anchor",
-          message: `Invalid evidence range: end_anchor resolved before start_anchor (${startCandidate.occurrenceId} -> ${endCandidate.occurrenceId}).`
-        }
-      ];
-    }
-    return [
-      {
-        confidence: Math.min(startCandidate.score, endCandidate.score),
-        sentenceIds: input.candidateSentenceIds.slice(
-          startCandidate.index,
-          endCandidate.index + 1
-        ),
-        strategy: `${startStrategy}+${endStrategy}`
-      },
-      void 0
-    ];
-  }
-  parseAnchor(value, fieldName) {
-    const [anchor, error] = this.#parseAnchor(value);
-    if (error !== void 0) {
-      return [
-        void 0,
-        {
-          candidates: [],
-          code: "invalid_anchor",
-          fieldName,
-          message: `Invalid evidence.${fieldName}: ${error}`
-        }
-      ];
-    }
-    return [this.#normalizeAnchor(anchor, fieldName), void 0];
-  }
-  resolveAnchor(input) {
-    if (input.anchor === void 0) {
-      return [
-        void 0,
-        "invalid",
-        {
-          candidates: [],
-          code: "invalid",
-          fieldName: input.label,
-          message: `${input.label} is missing`
-        }
-      ];
-    }
-    let candidates = this.rankAnchor(
-      input.anchor,
-      input.candidateSentenceIds,
-      input.candidateTexts,
-      input.label
-    );
-    const minIndex = input.minIndex;
-    if (minIndex !== void 0) {
-      candidates = candidates.filter(
-        (candidate) => candidate.index >= minIndex
-      );
-    }
-    if (candidates.length === 0) {
-      return [
-        void 0,
-        "none",
-        {
-          candidates: [],
-          code: "none",
-          fieldName: input.label,
-          message: `${input.label} could not be matched: no candidates available`
-        }
-      ];
-    }
-    const exactRaw = candidates.filter((candidate) => candidate.exactRaw);
-    if (exactRaw.length === 1) {
-      return [exactRaw[0], "exact_raw", void 0];
-    }
-    if (exactRaw.length > 1) {
-      return [
-        void 0,
-        "ambiguous_exact_raw",
-        this.#buildAmbiguousFailure(
-          input.label,
-          "ambiguous_exact_raw",
-          exactRaw
-        )
-      ];
-    }
-    const exactSubstring = candidates.filter(
-      (candidate) => candidate.exactSubstring
-    );
-    if (exactSubstring.length === 1 && this.#anchorLength(input.anchor) >= 8) {
-      return [exactSubstring[0], "exact_substring", void 0];
-    }
-    if (exactSubstring.length > 1 && this.#anchorLength(input.anchor) >= 8) {
-      const selected = this.#tryAutoSelectScoredDuplicates(exactSubstring);
-      if (selected !== void 0) {
-        return [selected, "exact_substring_scored", void 0];
-      }
-      return [
-        void 0,
-        "ambiguous_exact_substring",
-        this.#buildAmbiguousFailure(
-          input.label,
-          "ambiguous_exact_substring",
-          exactSubstring
-        )
-      ];
-    }
-    const exactNormalized = candidates.filter(
-      (candidate) => candidate.exactNormalized
-    );
-    if (exactNormalized.length === 1) {
-      return [exactNormalized[0], "exact_normalized", void 0];
-    }
-    if (exactNormalized.length > 1) {
-      const selected = this.#tryAutoSelectScoredDuplicates(exactNormalized);
-      if (selected !== void 0) {
-        return [selected, "exact_normalized_scored", void 0];
-      }
-      return [
-        void 0,
-        "ambiguous_exact_normalized",
-        this.#buildAmbiguousFailure(
-          input.label,
-          "ambiguous_exact_normalized",
-          exactNormalized
-        )
-      ];
-    }
-    const topCandidate = candidates[0];
-    if (topCandidate === void 0) {
-      return [
-        void 0,
-        "none",
-        {
-          candidates: [],
-          code: "none",
-          fieldName: input.label,
-          message: `${input.label} could not be matched: no candidates available`
-        }
-      ];
-    }
-    const secondScore = candidates[1]?.score ?? 0;
-    const gap = topCandidate.score - secondScore;
-    if (topCandidate.score < MIN_CANDIDATE_SCORE) {
-      return [
-        void 0,
-        "low_confidence",
-        {
-          candidates: candidates.slice(0, MAX_CANDIDATE_DISPLAY),
-          code: "low_confidence",
-          fieldName: input.label,
-          message: `${input.label} could not be matched confidently. Best candidate score=${topCandidate.score.toFixed(3)}.`
-        }
-      ];
-    }
-    if (candidates.length === 1) {
-      return [topCandidate, "auto_top1_single_candidate", void 0];
-    }
-    if (topCandidate.score >= VERY_HIGH_CONFIDENCE_SCORE) {
-      return [topCandidate, "auto_top1_very_high", void 0];
-    }
-    if (topCandidate.score >= MIN_AUTO_RESOLVE_SCORE && gap >= MIN_AUTO_RESOLVE_GAP) {
-      return [topCandidate, "auto_top1", void 0];
-    }
-    return [
-      void 0,
-      "ambiguous_ranked",
-      this.#buildAmbiguousFailure(input.label, "ambiguous_ranked", candidates)
-    ];
-  }
-  rankAnchor(anchor, candidateSentenceIds, candidateTexts, label) {
-    const ranked = [];
-    for (const [index, sentenceId] of candidateSentenceIds.entries()) {
-      const text = candidateTexts[index] ?? "";
-      const prevText = index > 0 ? candidateTexts[index - 1] ?? "" : "";
-      const nextText = index < candidateTexts.length - 1 ? candidateTexts[index + 1] ?? "" : "";
-      const match = this.#scoreAnchor(anchor, text, label);
-      ranked.push({
-        exactNormalized: match.exactNormalized,
-        exactRaw: match.exactRaw,
-        exactSubstring: match.exactSubstring,
-        index,
-        nextText,
-        occurrenceId: `S${index + 1}`,
-        prevText,
-        score: match.score,
-        sentenceId,
-        text
-      });
-    }
-    ranked.sort((left, right) => {
-      if (left.score !== right.score) {
-        return right.score - left.score;
-      }
-      if (left.exactRaw !== right.exactRaw) {
-        return left.exactRaw ? -1 : 1;
-      }
-      if (left.exactSubstring !== right.exactSubstring) {
-        return left.exactSubstring ? -1 : 1;
-      }
-      if (left.exactNormalized !== right.exactNormalized) {
-        return left.exactNormalized ? -1 : 1;
-      }
-      return left.index - right.index;
-    });
-    return ranked;
-  }
-  #scoreAnchor(anchor, candidateText, label) {
-    if (anchor.mode === "head_tail") {
-      return this.#scoreHeadTail(anchor, candidateText);
-    }
-    return this.#scoreTextQuery(anchor.text ?? "", candidateText, label);
-  }
-  #scoreHeadTail(anchor, candidateText) {
-    const head = anchor.head ?? "";
-    const tail = anchor.tail ?? "";
-    const candidateNormalized = normalizeText(candidateText);
-    const headNormalized = normalizeText(head);
-    const tailNormalized = normalizeText(tail);
-    if (headNormalized === "" || tailNormalized === "") {
-      return createEmptyTextMatchScore();
-    }
-    const headPosition = candidateNormalized.indexOf(headNormalized);
-    const tailPosition = candidateNormalized.lastIndexOf(tailNormalized);
-    if (headPosition !== -1 && tailPosition !== -1 && headPosition <= tailPosition) {
-      const coveredChars = headNormalized.length + tailNormalized.length;
-      const coverage = Math.min(
-        1,
-        coveredChars / Math.max(1, candidateNormalized.length)
-      );
-      return {
-        exactNormalized: false,
-        exactRaw: false,
-        exactSubstring: true,
-        matchEnd: tailPosition + tailNormalized.length,
-        matchStart: headPosition,
-        score: 0.82 + 0.18 * coverage
-      };
-    }
-    const headMatch = this.#scoreTextQuery(head, candidateText, "start_anchor");
-    const tailMatch = this.#scoreTextQuery(tail, candidateText, "end_anchor");
-    const ordered = headMatch.matchStart <= tailMatch.matchStart ? 1 : 0.85;
-    return {
-      exactNormalized: false,
-      exactRaw: false,
-      exactSubstring: false,
-      matchEnd: Math.max(headMatch.matchEnd, tailMatch.matchEnd),
-      matchStart: Math.min(headMatch.matchStart, tailMatch.matchStart),
-      score: (headMatch.score + tailMatch.score) / 2 * ordered
-    };
-  }
-  #scoreTextQuery(queryText, candidateText, label) {
-    const queryRaw = queryText.trim();
-    const candidateRaw = candidateText.trim();
-    const queryNormalized = normalizeText(queryRaw);
-    const candidateNormalized = normalizeText(candidateRaw);
-    if (queryNormalized === "" || candidateNormalized === "") {
-      return createEmptyTextMatchScore();
-    }
-    if (queryRaw === candidateRaw) {
-      return {
-        exactNormalized: true,
-        exactRaw: true,
-        exactSubstring: true,
-        matchEnd: candidateNormalized.length,
-        matchStart: 0,
-        score: 1
-      };
-    }
-    if (queryNormalized === candidateNormalized) {
-      return {
-        exactNormalized: true,
-        exactRaw: false,
-        exactSubstring: false,
-        matchEnd: candidateNormalized.length,
-        matchStart: 0,
-        score: 0.995
-      };
-    }
-    if (candidateNormalized.includes(queryNormalized)) {
-      const matchStart = candidateNormalized.indexOf(queryNormalized);
-      const coverage = queryNormalized.length / Math.max(1, candidateNormalized.length);
-      const boundaryBonus = this.#boundaryBonus({
-        candidateNormalized,
-        label,
-        matchEnd: matchStart + queryNormalized.length,
-        matchStart,
-        queryNormalized
-      });
-      return {
-        exactNormalized: false,
-        exactRaw: false,
-        exactSubstring: true,
-        matchEnd: matchStart + queryNormalized.length,
-        matchStart,
-        score: Math.min(1, 0.75 + 0.25 * coverage + boundaryBonus)
-      };
-    }
-    if (queryNormalized.includes(candidateNormalized)) {
-      const coverage = candidateNormalized.length / Math.max(1, queryNormalized.length);
-      return {
-        exactNormalized: false,
-        exactRaw: false,
-        exactSubstring: false,
-        matchEnd: candidateNormalized.length,
-        matchStart: 0,
-        score: Math.min(0.92, 0.78 + 0.14 * coverage)
-      };
-    }
-    let bestScore = 0;
-    let bestStart = -1;
-    let bestEnd = -1;
-    const maxWindow = Math.min(
-      candidateNormalized.length,
-      Math.max(
-        queryNormalized.length,
-        Math.floor(queryNormalized.length * 1.2)
-      )
-    );
-    const minWindow = Math.min(
-      maxWindow,
-      Math.max(1, Math.floor(queryNormalized.length * 0.8))
-    );
-    const queryChars = new Set(queryNormalized);
-    for (let windowSize = minWindow; windowSize <= maxWindow; windowSize += 1) {
-      for (let start = 0; start <= candidateNormalized.length - windowSize; start += 1) {
-        const window = candidateNormalized.slice(start, start + windowSize);
-        const windowChars = new Set(window);
-        const unionSize = (/* @__PURE__ */ new Set([...queryChars, ...windowChars])).size;
-        const overlapSize = [...queryChars].filter(
-          (char) => windowChars.has(char)
-        ).length;
-        const jaccard = unionSize === 0 ? 0 : overlapSize / unionSize;
-        if (jaccard < 0.35) {
-          continue;
-        }
-        const totalScore = 0.35 * charNgramScore(queryNormalized, window) + 0.35 * sequenceSimilarity(queryNormalized, window) + 0.2 * levenshteinSimilarity(queryNormalized, window) + 0.1 * lengthPenalty(queryNormalized, window) + this.#boundaryBonus({
-          candidateNormalized,
-          label,
-          matchEnd: start + windowSize,
-          matchStart: start,
-          queryNormalized
-        });
-        if (totalScore > bestScore) {
-          bestScore = Math.min(1, totalScore);
-          bestStart = start;
-          bestEnd = start + windowSize;
-        }
-      }
-    }
-    return {
-      exactNormalized: false,
-      exactRaw: false,
-      exactSubstring: false,
-      matchEnd: bestEnd,
-      matchStart: bestStart,
-      score: bestScore
-    };
-  }
-  #parseAnchor(value) {
-    if (value === void 0 || value === null) {
-      return [void 0, "anchor is required"];
-    }
-    if (typeof value === "string") {
-      const stripped = value.trim();
-      if (stripped === "") {
-        return [void 0, "anchor string is empty"];
-      }
-      if (stripped.includes("...")) {
-        const parts = stripped.split("...").map((part) => part.trim()).filter((part) => part !== "");
-        if (parts.length >= 2) {
-          const head2 = parts[0];
-          const tail2 = parts[parts.length - 1];
-          if (head2 === void 0 || tail2 === void 0) {
-            return [void 0, "anchor string is empty"];
-          }
-          return [
-            {
-              head: head2,
-              mode: "head_tail",
-              tail: tail2
-            },
-            void 0
-          ];
-        }
-      }
-      return [{ mode: "full", text: stripped }, void 0];
-    }
-    if (typeof value !== "object") {
-      return [void 0, `expected string or object, got ${typeof value}`];
-    }
-    const rawValue = value;
-    const mode = rawValue.mode === "head_tail" || rawValue.head !== void 0 ? "head_tail" : "full";
-    if (mode === "full") {
-      const text = typeof rawValue.text === "string" ? rawValue.text.trim() : "";
-      if (text === "") {
-        return [void 0, "full anchor requires non-empty 'text'"];
-      }
-      return [{ mode: "full", text }, void 0];
-    }
-    const head = typeof rawValue.head === "string" ? rawValue.head.trim() : "";
-    const tail = typeof rawValue.tail === "string" ? rawValue.tail.trim() : "";
-    if (head !== "" && tail === "") {
-      return [{ mode: "full", text: head }, void 0];
-    }
-    if (head === "" && tail !== "") {
-      return [{ mode: "full", text: tail }, void 0];
-    }
-    if (head === "" || tail === "") {
-      return [
-        void 0,
-        "head_tail anchor requires non-empty 'head' and 'tail'"
-      ];
-    }
-    return [{ head, mode: "head_tail", tail }, void 0];
-  }
-  #normalizeAnchor(anchor, fieldName) {
-    if (anchor === void 0) {
-      return void 0;
-    }
-    if (anchor.mode === "head_tail") {
-      const boundaryText = fieldName === "end_anchor" ? this.#selectBoundarySentence(anchor.tail ?? "", "end_anchor") : this.#selectBoundarySentence(anchor.head ?? "", "start_anchor");
-      return boundaryText === "" ? void 0 : {
-        mode: "full",
-        text: boundaryText
-      };
-    }
-    const normalizedText = this.#selectBoundarySentence(
-      anchor.text ?? "",
-      fieldName
-    );
-    return {
-      mode: "full",
-      text: normalizedText
-    };
-  }
-  #selectBoundarySentence(text, fieldName) {
-    const sentences = splitTextIntoSentences(text);
-    if (sentences.length <= 1) {
-      return text.trim();
-    }
-    return fieldName === "end_anchor" ? sentences[sentences.length - 1] ?? text.trim() : sentences[0] ?? text.trim();
-  }
-  #boundaryBonus(input) {
-    if (input.matchStart < 0 || input.matchEnd < 0) {
-      return 0;
-    }
-    if (input.queryNormalized.length < MIN_BOUNDARY_BONUS_LENGTH) {
-      return 0;
-    }
-    if (input.label === "start_anchor" && input.matchStart !== 0) {
-      return 0;
-    }
-    if (input.label === "end_anchor" && input.matchEnd !== input.candidateNormalized.length) {
-      return 0;
-    }
-    const coverage = input.queryNormalized.length / Math.max(1, input.candidateNormalized.length);
-    return MAX_BOUNDARY_BONUS * (0.5 + 0.5 * Math.min(1, coverage));
-  }
-  #tryAutoSelectScoredDuplicates(candidates) {
-    if (candidates.length === 0) {
-      return void 0;
-    }
-    if (candidates.length === 1) {
-      return candidates[0];
-    }
-    const topCandidate = candidates[0];
-    if (topCandidate === void 0) {
-      return void 0;
-    }
-    const secondScore = candidates[1]?.score ?? 0;
-    if (topCandidate.score >= MIN_AUTO_RESOLVE_SCORE && topCandidate.score - secondScore >= MIN_AUTO_RESOLVE_GAP) {
-      return topCandidate;
-    }
-    return void 0;
-  }
-  #buildAmbiguousFailure(label, code, candidates) {
-    const topCandidates = candidates.slice(0, MAX_CANDIDATE_DISPLAY);
-    const formatted = topCandidates.map((candidate) => formatCandidate(candidate)).join("\n");
-    return {
-      candidates: topCandidates,
-      code,
-      fieldName: label,
-      message: `${label} is ambiguous. Top candidates:
-${formatted}
-Please provide a more specific anchor or surrounding context.`
-    };
-  }
-  #anchorLength(anchor) {
-    if (anchor.mode === "head_tail") {
-      return normalizeText(anchor.head ?? "").length + normalizeText(anchor.tail ?? "").length;
-    }
-    return normalizeText(anchor.text ?? "").length;
-  }
-}
-function createEmptyTextMatchScore() {
-  return {
-    exactNormalized: false,
-    exactRaw: false,
-    exactSubstring: false,
-    matchEnd: -1,
-    matchStart: -1,
-    score: 0
-  };
-}
-function charNgramScore(left, right) {
-  const leftBigrams = charNgrams(left, 2);
-  const rightBigrams = charNgrams(right, 2);
-  const leftTrigrams = charNgrams(left, 3);
-  const rightTrigrams = charNgrams(right, 3);
-  return (diceCoefficient(leftBigrams, rightBigrams) + diceCoefficient(leftTrigrams, rightTrigrams)) / 2;
-}
-function charNgrams(text, size) {
-  if (text.length <= size) {
-    return text === "" ? /* @__PURE__ */ new Set() : /* @__PURE__ */ new Set([text]);
-  }
-  const result = /* @__PURE__ */ new Set();
-  for (let index = 0; index <= text.length - size; index += 1) {
-    result.add(text.slice(index, index + size));
-  }
-  return result;
-}
-function diceCoefficient(left, right) {
-  if (left.size === 0 || right.size === 0) {
-    return 0;
-  }
-  let overlap = 0;
-  for (const value of left) {
-    if (right.has(value)) {
-      overlap += 1;
-    }
-  }
-  return 2 * overlap / (left.size + right.size);
-}
-function levenshteinSimilarity(left, right) {
-  if (left === right) {
-    return 1;
-  }
-  if (left === "" || right === "") {
-    return 0;
-  }
-  let previous = Array.from({ length: right.length + 1 }, (_, index) => index);
-  let current = new Array(right.length + 1).fill(0);
-  for (const [leftIndex, leftChar] of [...left].entries()) {
-    current[0] = leftIndex + 1;
-    for (const [rightIndex, rightChar] of [...right].entries()) {
-      const insertCost = (current[rightIndex] ?? 0) + 1;
-      const deleteCost = (previous[rightIndex + 1] ?? 0) + 1;
-      const replaceCost = (previous[rightIndex] ?? 0) + (leftChar === rightChar ? 0 : 1);
-      current[rightIndex + 1] = Math.min(insertCost, deleteCost, replaceCost);
-    }
-    [previous, current] = [current, previous];
-  }
-  const distance = previous[right.length] ?? Math.max(left.length, right.length);
-  return 1 - distance / Math.max(left.length, right.length);
-}
-function lengthPenalty(left, right) {
-  return 1 - Math.abs(left.length - right.length) / Math.max(left.length, right.length);
-}
-function sequenceSimilarity(left, right) {
-  if (left === right) {
-    return 1;
-  }
-  const leftLength = left.length;
-  const rightLength = right.length;
-  if (leftLength === 0 || rightLength === 0) {
-    return 0;
-  }
-  const matrix = Array.from(
-    { length: leftLength + 1 },
-    () => new Array(rightLength + 1).fill(0)
-  );
-  let longest = 0;
-  for (let leftIndex = 1; leftIndex <= leftLength; leftIndex += 1) {
-    for (let rightIndex = 1; rightIndex <= rightLength; rightIndex += 1) {
-      if (left[leftIndex - 1] !== right[rightIndex - 1]) {
-        continue;
-      }
-      const currentRow = matrix[leftIndex];
-      if (currentRow === void 0) {
-        continue;
-      }
-      currentRow[rightIndex] = (matrix[leftIndex - 1]?.[rightIndex - 1] ?? 0) + 1;
-      longest = Math.max(longest, currentRow[rightIndex] ?? 0);
-    }
-  }
-  return 2 * longest / (leftLength + rightLength);
-}
-function formatCandidate(candidate) {
-  return `  - ${candidate.occurrenceId} score=${candidate.score.toFixed(3)}
-    prev: ${truncate(candidate.prevText)}
-    text: ${truncate(candidate.text, 120)}
-    next: ${truncate(candidate.nextText)}`;
-}
-function truncate(text, limit = 80) {
-  const stripped = text.replace(/\s+/gu, " ").trim();
-  if (stripped === "") {
-    return "(none)";
-  }
-  if (stripped.length <= limit) {
-    return stripped;
-  }
-  return `${stripped.slice(0, limit - 3)}...`;
-}
-export {
-  EvidenceResolver
-};
-//# sourceMappingURL=anchor-resolver.js.map