@remnic/core 9.28.0 → 9.29.1

package/dist/chunk-P2BM76KT.js

@@ -0,0 +1,528 @@
+// src/extraction-source-grounding-helpers.ts
+function isInterrogativeSourceSentence(sentence) {
+  const normalized = sentence.trim();
+  const embeddedQuestionVerbIndex = normalized.search(
+    /\b(?:determine|know|wonder|ask(?:ed)?|question|decide|check|confirm|find|figure|understand|unclear)\b/iu
+  );
+  const embeddedQuestionMarkerIndex = normalized.search(/\b(?:whether|if)\b/iu);
+  const hasEmbeddedQuestion = embeddedQuestionVerbIndex >= 0 && embeddedQuestionMarkerIndex > embeddedQuestionVerbIndex;
+  return normalized.endsWith("?") || hasEmbeddedQuestion || !normalized.includes(":") && /^(?:suppose|assuming|assume|maybe|perhaps|hypothetically|if|whether|imagine|imagining|presume|presuming|supposing|is|are|am|was|were|do|does|did|can|could|will|would|should|has|have|had|what|which|when|where|why|how|who)\b/iu.test(
+    normalized
+  );
+}
+function containsContiguousGroundingTokens(candidateTokens, sourceTokens) {
+  if (candidateTokens.length === 0 || candidateTokens.length > sourceTokens.length) return false;
+  return sourceTokens.some(
+    (_, start) => candidateTokens.every((token, offset) => sourceTokens[start + offset] === token)
+  );
+}
+function hasExplicitRoleSubjectToken(candidateRole, sourceTokensBySentence) {
+  return candidateRole !== void 0 && sourceTokensBySentence.some((tokens) => tokens.includes(candidateRole));
+}
+function splitGroundingClauses(sentences) {
+  return sentences.flatMap(
+    (sentence) => sentence.split(/,\s+(?=[\p{L}][\p{L}\p{N}'’-]*\s+\S)/gu).flatMap(
+      (commaClause) => commaClause.split(/\s*(?::|[—–])\s+|\s+\/\s+/u).flatMap(
+        (delimiterClause) => delimiterClause.split(/\s+(?:and|but|or|while|although|because)\s+/gu).map((clause) => clause.trim()).filter((clause) => clause.length > 0)
+      )
+    )
+  );
+}
+var GROUNDING_STOPWORDS = {
+  a: true,
+  an: true,
+  and: true,
+  are: true,
+  as: true,
+  at: true,
+  be: true,
+  been: true,
+  being: true,
+  but: true,
+  by: true,
+  can: true,
+  could: true,
+  did: true,
+  do: true,
+  does: true,
+  for: true,
+  from: true,
+  had: true,
+  has: true,
+  have: true,
+  he: true,
+  her: true,
+  here: true,
+  hers: true,
+  him: true,
+  his: true,
+  how: true,
+  i: true,
+  if: true,
+  in: true,
+  into: true,
+  is: true,
+  it: true,
+  its: true,
+  just: true,
+  me: true,
+  my: true,
+  no: true,
+  not: true,
+  of: true,
+  on: true,
+  only: true,
+  or: true,
+  our: true,
+  ours: true,
+  she: true,
+  so: true,
+  than: true,
+  that: true,
+  the: true,
+  their: true,
+  them: true,
+  then: true,
+  there: true,
+  these: true,
+  they: true,
+  this: true,
+  those: true,
+  to: true,
+  too: true,
+  under: true,
+  up: true,
+  us: true,
+  very: true,
+  was: true,
+  we: true,
+  were: true,
+  what: true,
+  when: true,
+  why: true,
+  where: true,
+  which: true,
+  who: true,
+  will: true,
+  with: true,
+  would: true,
+  you: true,
+  your: true
+};
+var GROUNDING_NEGATION_TOKENS = /* @__PURE__ */ new Set([
+  "no",
+  "not",
+  "false",
+  "untrue",
+  "incorrect",
+  "wrong",
+  "never",
+  "without",
+  "neither",
+  "nor",
+  "none",
+  "cannot",
+  "cant",
+  "can't",
+  "don't",
+  "doesn't",
+  "didn't",
+  "isn't",
+  "aren't",
+  "wasn't",
+  "weren't",
+  "won't",
+  "wouldn't",
+  "couldn't",
+  "shouldn't",
+  "haven't",
+  "hasn't",
+  "hadn't"
+]);
+var GROUNDING_AUXILIARY_TOKENS = /* @__PURE__ */ new Set([
+  "am",
+  "are",
+  "be",
+  "been",
+  "being",
+  "can",
+  "could",
+  "did",
+  "do",
+  "does",
+  "had",
+  "has",
+  "have",
+  "is",
+  "was",
+  "were",
+  "will",
+  "would",
+  "should"
+]);
+var GROUNDING_COPULAR_FORMS = /* @__PURE__ */ new Set([
+  "am",
+  "are",
+  "be",
+  "been",
+  "being",
+  "is",
+  "was",
+  "were"
+]);
+var GROUNDING_SUBJECT_PRONOUNS = /* @__PURE__ */ new Set([
+  "he",
+  "she",
+  "they",
+  "it",
+  "i",
+  "we",
+  "you"
+]);
+var GROUNDING_ENTITY_TYPE_PREFIXES = /* @__PURE__ */ new Set([
+  "person",
+  "project",
+  "tool",
+  "company",
+  "place",
+  "other"
+]);
+var GROUNDING_COMMON_VERB_FORMS = /* @__PURE__ */ new Set([
+  "contains",
+  "employs",
+  "gives",
+  "has",
+  "hosts",
+  "likes",
+  "makes",
+  "needs",
+  "owns",
+  "prefers",
+  "requires",
+  "runs",
+  "shares",
+  "supports",
+  "takes",
+  "uses",
+  "wants",
+  "works"
+]);
+function groundingLexemes(text) {
+  return text.normalize("NFKC").match(
+    /[\p{L}\p{N}]+(?:['’][\p{L}\p{N}]+)?(?:\+\+[\p{L}\p{N}]*|#[\p{L}\p{N}]*)?/gu
+  )?.map((rawToken) => {
+    const token = rawToken.replaceAll("\u2019", "'").toLocaleLowerCase();
+    return {
+      token,
+      preserveTerminalS: /^\p{Lu}/u.test(rawToken) && !GROUNDING_COMMON_VERB_FORMS.has(token)
+    };
+  }) ?? [];
+}
+function tokenSequence(text) {
+  return groundingLexemes(text).map(({ token }) => token);
+}
+function containsExactTokenSequence(candidate, source) {
+  const candidateTokens = tokenSequence(candidate);
+  const sourceTokens = tokenSequence(source);
+  if (candidateTokens.length === 0 || candidateTokens.length > sourceTokens.length) return false;
+  return sourceTokens.some(
+    (_, index) => candidateTokens.every((token, offset) => sourceTokens[index + offset] === token)
+  );
+}
+function isNegationCue(token) {
+  return GROUNDING_NEGATION_TOKENS.has(token) || token.endsWith("n't");
+}
+function isAttachedNegatedAuxiliary(token) {
+  return token.endsWith("n't") || token === "cannot" || token === "cant" || token === "can't";
+}
+function isNegatedAt(tokens, index) {
+  if (tokens[index - 1] === "only" && tokens[index - 2] === "not") return false;
+  const previousStart = Math.max(0, index - 2);
+  for (let i = previousStart; i < index; i += 1) {
+    if (isNegationCue(tokens[i])) return true;
+  }
+  if (tokens[index - 1] === "than" && tokens[index - 2] === "rather") return true;
+  if (tokens[index - 1] === "of" && tokens[index - 2] === "instead") return true;
+  const next = tokens[index + 1];
+  if (next !== void 0 && isAttachedNegatedAuxiliary(next)) return true;
+  const nextNext = tokens[index + 2];
+  return next !== void 0 && nextNext !== void 0 && GROUNDING_AUXILIARY_TOKENS.has(next) && isNegationCue(nextNext);
+}
+var GROUNDING_MIN_SHARED_TOKENS = 2;
+var GROUNDING_MIN_COVERAGE = 0.5;
+function stemToken(token, preserveTerminalS = false) {
+  if (token.endsWith("'s")) return token.slice(0, -2);
+  if (preserveTerminalS) return token;
+  if (token.length > 5 && token.endsWith("ing")) {
+    const stem = token.slice(0, -3);
+    return /(.)\1$/u.test(stem) ? stem.slice(0, -1) : stem;
+  }
+  if (token.length > 4 && token.endsWith("ed")) return token.slice(0, -2);
+  if (!preserveTerminalS && token.length > 3 && token.endsWith("s") && !token.endsWith("ss") && GROUNDING_COMMON_VERB_FORMS.has(token)) {
+    return token.slice(0, -1);
+  }
+  return token;
+}
+function tokenize(text) {
+  const tokens = /* @__PURE__ */ new Set();
+  for (const { token, preserveTerminalS } of groundingLexemes(text)) {
+    if (GROUNDING_STOPWORDS[token] !== true) tokens.add(stemToken(token, preserveTerminalS));
+  }
+  return tokens;
+}
+function normalizeForExactMatch(text) {
+  return text.normalize("NFKC").toLocaleLowerCase().replace(/\s+/gu, " ").trim();
+}
+function sourceSentences(source) {
+  const sentences = [];
+  let sentenceStart = 0;
+  for (let index = 0; index < source.length; index += 1) {
+    const character = source[index];
+    const nextCharacter = source[index + 1];
+    const boundary = character === "!" || character === "?" || character === ";" || character === "\n" || character === "." && (nextCharacter === void 0 || /\s/u.test(nextCharacter) || /["')\]}]/u.test(nextCharacter));
+    if (!boundary) continue;
+    let sentenceEnd = character === "\n" ? index : index + 1;
+    while (/[.!?;\n]/u.test(source[sentenceEnd] ?? "")) sentenceEnd += 1;
+    const sentence = source.slice(sentenceStart, sentenceEnd).trim();
+    if (sentence.length > 0) sentences.push(sentence);
+    sentenceStart = sentenceEnd;
+    index = sentenceEnd - 1;
+  }
+  const trailingSentence = source.slice(sentenceStart).trim();
+  if (trailingSentence.length > 0) sentences.push(trailingSentence);
+  return sentences.length > 0 ? sentences : [source];
+}
+function groundingTokenSequence(text) {
+  let lexemes = groundingLexemes(text);
+  while (lexemes.length > 0 && GROUNDING_AUXILIARY_TOKENS.has(lexemes[0].token)) {
+    lexemes = lexemes.slice(1);
+  }
+  return lexemes.filter(({ token }) => GROUNDING_STOPWORDS[token] !== true).map(({ token, preserveTerminalS }) => stemToken(token, preserveTerminalS));
+}
+function normalizedGroundingAlignmentTokenSequence(text) {
+  const normalized = normalizedGroundingTokenSequence(text);
+  const firstLexeme = groundingLexemes(text)[0];
+  if (firstLexeme === void 0 || !GROUNDING_SUBJECT_PRONOUNS.has(firstLexeme.token)) {
+    return normalized;
+  }
+  return [stemToken(firstLexeme.token, firstLexeme.preserveTerminalS), ...normalized];
+}
+function normalizedGroundingTokenSequence(text) {
+  return groundingTokenSequence(text).map((token) => token.replace(/'$/u, ""));
+}
+function areGroundingTokensCompatible(left, right) {
+  return left === right || `${left}e` === right || left === `${right}e`;
+}
+var GROUNDING_DENIAL_REPORTING_VERBS = /* @__PURE__ */ new Set([
+  "deny",
+  "denied",
+  "denies",
+  "denying",
+  "dispute",
+  "disputed",
+  "disputes",
+  "disputing",
+  "reject",
+  "rejected",
+  "rejects",
+  "rejecting",
+  "refute",
+  "refuted",
+  "refutes",
+  "refuting",
+  "contradict",
+  "contradicted",
+  "contradicts",
+  "contradicting",
+  "disprove",
+  "disproved",
+  "disproves",
+  "disproving"
+]);
+function isDenialReportingVerb(token) {
+  return GROUNDING_DENIAL_REPORTING_VERBS.has(token);
+}
+var GROUNDING_NON_ASSERTIVE_REPORTING_VERBS = /* @__PURE__ */ new Set([
+  "allege",
+  "alleged",
+  "alleges",
+  "alleging",
+  "allegedly",
+  "assert",
+  "asserted",
+  "asserts",
+  "asserting",
+  "believe",
+  "believed",
+  "believes",
+  "believing",
+  "claim",
+  "claimed",
+  "claims",
+  "claiming",
+  "doubt",
+  "doubted",
+  "doubts",
+  "doubting",
+  "uncertain",
+  "unsure",
+  "unclear",
+  "unknown",
+  "possibly",
+  "probably",
+  "imagine",
+  "imagined",
+  "imagines",
+  "imagining",
+  "report",
+  "reported",
+  "reports",
+  "reporting",
+  "reportedly",
+  "say",
+  "said",
+  "says",
+  "saying",
+  "speculate",
+  "speculated",
+  "speculates",
+  "speculating",
+  "suspect",
+  "suspected",
+  "suspects",
+  "suspecting",
+  "suppose",
+  "supposed",
+  "supposes",
+  "supposing",
+  "supposedly",
+  "think",
+  "thought",
+  "thinks",
+  "thinking"
+]);
+function isNonAssertiveReportingVerb(token) {
+  return GROUNDING_NON_ASSERTIVE_REPORTING_VERBS.has(token);
+}
+function isGroundingClauseBoundary(token) {
+  return token === "and" || token === "but" || token === "or" || token === "while" || token === "although" || token === "because";
+}
+function isNonAssertiveReportingAt(tokens, index) {
+  let boundary = 0;
+  for (let cursor = 0; cursor < index; cursor += 1) {
+    if (isGroundingClauseBoundary(tokens[cursor])) boundary = cursor + 1;
+  }
+  for (let cursor = index - 1; cursor >= boundary; cursor -= 1) {
+    if (tokens[cursor] === "that" && cursor > boundary && isNonAssertiveReportingVerb(tokens[cursor - 1])) {
+      return true;
+    }
+    if (isNonAssertiveReportingVerb(tokens[cursor]) && index - cursor <= 5) return true;
+  }
+  return false;
+}
+function isDeniedAt(tokens, index) {
+  let boundary = 0;
+  for (let cursor = 0; cursor < index; cursor += 1) {
+    if (isGroundingClauseBoundary(tokens[cursor])) boundary = cursor + 1;
+  }
+  for (let cursor = index - 1; cursor >= boundary; cursor -= 1) {
+    const token = tokens[cursor];
+    if (token === "that" && cursor > boundary && isDenialReportingVerb(tokens[cursor - 1])) {
+      return true;
+    }
+    if (isDenialReportingVerb(token) && index - cursor <= 5) return true;
+  }
+  return false;
+}
+function hasContradictoryPolarity(candidate, source) {
+  const candidateLexemes = groundingLexemes(candidate);
+  const candidateTokens = candidateLexemes.map(({ token }) => token);
+  let coherentContradiction = false;
+  for (const clause of sourceSentences(source).flatMap((sentence) => sentence.split(/\s+(?:and|but|or|while|although|because)\s+/gu))) {
+    const sourceLexemes2 = groundingLexemes(clause);
+    const sourceTokens2 = sourceLexemes2.map(({ token }) => token);
+    let sourceCursor = 0;
+    let allTokensFound = true;
+    let contradiction = false;
+    for (const [candidateIndex, candidateToken] of candidateTokens.entries()) {
+      if (GROUNDING_STOPWORDS[candidateToken] === true) continue;
+      const sourceIndex = sourceTokens2.findIndex(
+        (sourceToken, index) => index >= sourceCursor && stemToken(sourceToken, sourceLexemes2[index]?.preserveTerminalS === true) === stemToken(candidateToken, candidateLexemes[candidateIndex]?.preserveTerminalS === true)
+      );
+      if (sourceIndex === -1) {
+        allTokensFound = false;
+        break;
+      }
+      const candidateNegated = isNegatedAt(candidateTokens, candidateIndex) || isDeniedAt(candidateTokens, candidateIndex);
+      const sourceNegated = isNegatedAt(sourceTokens2, sourceIndex) || isDeniedAt(sourceTokens2, sourceIndex);
+      const candidateNonAssertive = isNonAssertiveReportingAt(candidateTokens, candidateIndex);
+      const sourceNonAssertive = isNonAssertiveReportingAt(sourceTokens2, sourceIndex);
+      if (candidateNegated !== sourceNegated || candidateNonAssertive !== sourceNonAssertive) {
+        contradiction = true;
+      }
+      sourceCursor = sourceIndex + 1;
+    }
+    if (allTokensFound) {
+      if (!contradiction) return false;
+      coherentContradiction = true;
+    }
+  }
+  if (coherentContradiction) return true;
+  const sourceLexemes = groundingLexemes(source);
+  const sourceTokens = sourceLexemes.map(({ token }) => token);
+  const sourcePositions = /* @__PURE__ */ new Map();
+  sourceLexemes.forEach(({ token, preserveTerminalS }, index) => {
+    const key = stemToken(token, preserveTerminalS);
+    const positions = sourcePositions.get(key);
+    if (positions) positions.push(index);
+    else sourcePositions.set(key, [index]);
+  });
+  for (const [candidateIndex, token] of candidateTokens.entries()) {
+    if (GROUNDING_STOPWORDS[token] === true) continue;
+    const positions = sourcePositions.get(
+      stemToken(token, candidateLexemes[candidateIndex]?.preserveTerminalS === true)
+    );
+    if (!positions || positions.length === 0) continue;
+    const sourceIndex = positions[positions.length - 1];
+    const candidateNegated = isNegatedAt(candidateTokens, candidateIndex) || isDeniedAt(candidateTokens, candidateIndex);
+    const sourceNegated = isNegatedAt(sourceTokens, sourceIndex) || isDeniedAt(sourceTokens, sourceIndex);
+    const candidateNonAssertive = isNonAssertiveReportingAt(candidateTokens, candidateIndex);
+    const sourceNonAssertive = isNonAssertiveReportingAt(sourceTokens, sourceIndex);
+    if (candidateNegated !== sourceNegated || candidateNonAssertive !== sourceNonAssertive) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export {
+  isInterrogativeSourceSentence,
+  containsContiguousGroundingTokens,
+  hasExplicitRoleSubjectToken,
+  splitGroundingClauses,
+  GROUNDING_STOPWORDS,
+  GROUNDING_NEGATION_TOKENS,
+  GROUNDING_AUXILIARY_TOKENS,
+  GROUNDING_COPULAR_FORMS,
+  GROUNDING_SUBJECT_PRONOUNS,
+  GROUNDING_ENTITY_TYPE_PREFIXES,
+  GROUNDING_COMMON_VERB_FORMS,
+  groundingLexemes,
+  tokenSequence,
+  containsExactTokenSequence,
+  isNegationCue,
+  isAttachedNegatedAuxiliary,
+  isNegatedAt,
+  GROUNDING_MIN_SHARED_TOKENS,
+  GROUNDING_MIN_COVERAGE,
+  stemToken,
+  tokenize,
+  normalizeForExactMatch,
+  sourceSentences,
+  groundingTokenSequence,
+  normalizedGroundingAlignmentTokenSequence,
+  normalizedGroundingTokenSequence,
+  areGroundingTokensCompatible,
+  hasContradictoryPolarity
+};
+//# sourceMappingURL=chunk-P2BM76KT.js.map

package/dist/chunk-P2BM76KT.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/extraction-source-grounding-helpers.ts"],"sourcesContent":["export function isInterrogativeSourceSentence(sentence: string): boolean {\n  const normalized = sentence.trim();\n  const embeddedQuestionVerbIndex = normalized.search(\n    /\\b(?:determine|know|wonder|ask(?:ed)?|question|decide|check|confirm|find|figure|understand|unclear)\\b/iu,\n  );\n  const embeddedQuestionMarkerIndex = normalized.search(/\\b(?:whether|if)\\b/iu);\n  const hasEmbeddedQuestion = embeddedQuestionVerbIndex >= 0\n    && embeddedQuestionMarkerIndex > embeddedQuestionVerbIndex;\n  return normalized.endsWith(\"?\")\n    || hasEmbeddedQuestion\n    || (\n      !normalized.includes(\":\")\n      && /^(?:suppose|assuming|assume|maybe|perhaps|hypothetically|if|whether|imagine|imagining|presume|presuming|supposing|is|are|am|was|were|do|does|did|can|could|will|would|should|has|have|had|what|which|when|where|why|how|who)\\b/iu.test(\n        normalized,\n      )\n    );\n}\n\nexport function containsContiguousGroundingTokens(\n  candidateTokens: ReadonlyArray<string>,\n  sourceTokens: ReadonlyArray<string>,\n): boolean {\n  if (candidateTokens.length === 0 || candidateTokens.length > sourceTokens.length) return false;\n  return sourceTokens.some((_, start) =>\n    candidateTokens.every((token, offset) => sourceTokens[start + offset] === token),\n  );\n}\n\nexport function hasExplicitRoleSubjectToken(\n  candidateRole: string | undefined,\n  sourceTokensBySentence: ReadonlyArray<ReadonlyArray<string>>,\n): boolean {\n  return candidateRole !== undefined\n    && sourceTokensBySentence.some((tokens) => tokens.includes(candidateRole));\n}\n\nexport function splitGroundingClauses(sentences: ReadonlyArray<string>): string[] {\n  return sentences.flatMap((sentence) =>\n    sentence\n      .split(/,\\s+(?=[\\p{L}][\\p{L}\\p{N}'’-]*\\s+\\S)/gu)\n      .flatMap((commaClause) =>\n        commaClause\n          .split(/\\s*(?::|[—–])\\s+|\\s+\\/\\s+/u)\n          .flatMap((delimiterClause) =>\n            delimiterClause\n              .split(/\\s+(?:and|but|or|while|although|because)\\s+/gu)\n              .map((clause) => clause.trim())\n              .filter((clause) => clause.length > 0),\n          ),\n      ),\n  );\n}\n\nexport const GROUNDING_STOPWORDS: Record<string, true> = {\n  a: true,\n  an: true,\n  and: true,\n  are: true,\n  as: true,\n  at: true,\n  be: true,\n  been: true,\n  being: true,\n  but: true,\n  by: true,\n  can: true,\n  could: true,\n  did: true,\n  do: true,\n  does: true,\n  for: true,\n  from: true,\n  had: true,\n  has: true,\n  have: true,\n  he: true,\n  her: true,\n  here: true,\n  hers: true,\n  him: true,\n  his: true,\n  how: true,\n  i: true,\n  if: true,\n  in: true,\n  into: true,\n  is: true,\n  it: true,\n  its: true,\n  just: true,\n  me: true,\n  my: true,\n  no: true,\n  not: true,\n  of: true,\n  on: true,\n  only: true,\n  or: true,\n  our: true,\n  ours: true,\n  she: true,\n  so: true,\n  than: true,\n  that: true,\n  the: true,\n  their: true,\n  them: true,\n  then: true,\n  there: true,\n  these: true,\n  they: true,\n  this: true,\n  those: true,\n  to: true,\n  too: true,\n  under: true,\n  up: true,\n  us: true,\n  very: true,\n  was: true,\n  we: true,\n  were: true,\n  what: true,\n  when: true,\n  why: true,\n  where: true,\n  which: true,\n  who: true,\n  will: true,\n  with: true,\n  would: true,\n  you: true,\n  your: true,\n};\n\nexport const GROUNDING_NEGATION_TOKENS = new Set([\n  \"no\",\n  \"not\",\n  \"false\",\n  \"untrue\",\n  \"incorrect\",\n  \"wrong\",\n  \"never\",\n  \"without\",\n  \"neither\",\n  \"nor\",\n  \"none\",\n  \"cannot\",\n  \"cant\",\n  \"can't\",\n  \"don't\",\n  \"doesn't\",\n  \"didn't\",\n  \"isn't\",\n  \"aren't\",\n  \"wasn't\",\n  \"weren't\",\n  \"won't\",\n  \"wouldn't\",\n  \"couldn't\",\n  \"shouldn't\",\n  \"haven't\",\n  \"hasn't\",\n  \"hadn't\",\n]);\n\nexport const GROUNDING_AUXILIARY_TOKENS = new Set([\n  \"am\",\n  \"are\",\n  \"be\",\n  \"been\",\n  \"being\",\n  \"can\",\n  \"could\",\n  \"did\",\n  \"do\",\n  \"does\",\n  \"had\",\n  \"has\",\n  \"have\",\n  \"is\",\n  \"was\",\n  \"were\",\n  \"will\",\n  \"would\",\n  \"should\",\n]);\n\nexport const GROUNDING_COPULAR_FORMS = new Set([\n  \"am\",\n  \"are\",\n  \"be\",\n  \"been\",\n  \"being\",\n  \"is\",\n  \"was\",\n  \"were\",\n]);\n\nexport const GROUNDING_SUBJECT_PRONOUNS = new Set([\n  \"he\",\n  \"she\",\n  \"they\",\n  \"it\",\n  \"i\",\n  \"we\",\n  \"you\",\n]);\nexport const GROUNDING_ENTITY_TYPE_PREFIXES = new Set([\n  \"person\",\n  \"project\",\n  \"tool\",\n  \"company\",\n  \"place\",\n  \"other\",\n]);\n\nexport const GROUNDING_COMMON_VERB_FORMS = new Set([\n  \"contains\",\n  \"employs\",\n  \"gives\",\n  \"has\",\n  \"hosts\",\n  \"likes\",\n  \"makes\",\n  \"needs\",\n  \"owns\",\n  \"prefers\",\n  \"requires\",\n  \"runs\",\n  \"shares\",\n  \"supports\",\n  \"takes\",\n  \"uses\",\n  \"wants\",\n  \"works\",\n]);\n\nexport interface GroundingLexeme {\n  token: string;\n  preserveTerminalS: boolean;\n}\n\nexport function groundingLexemes(text: string): GroundingLexeme[] {\n  return text.normalize(\"NFKC\").match(\n    /[\\p{L}\\p{N}]+(?:['’][\\p{L}\\p{N}]+)?(?:\\+\\+[\\p{L}\\p{N}]*|#[\\p{L}\\p{N}]*)?/gu,\n  )\n    ?.map((rawToken) => {\n      const token = rawToken.replaceAll(\"’\", \"'\").toLocaleLowerCase();\n      return {\n        token,\n        preserveTerminalS: /^\\p{Lu}/u.test(rawToken) && !GROUNDING_COMMON_VERB_FORMS.has(token),\n      };\n    })\n    ?? [];\n}\n\nexport function tokenSequence(text: string): string[] {\n  return groundingLexemes(text).map(({ token }) => token);\n}\n\nexport function containsExactTokenSequence(candidate: string, source: string): boolean {\n  const candidateTokens = tokenSequence(candidate);\n  const sourceTokens = tokenSequence(source);\n  if (candidateTokens.length === 0 || candidateTokens.length > sourceTokens.length) return false;\n  return sourceTokens.some((_, index) =>\n    candidateTokens.every((token, offset) => sourceTokens[index + offset] === token),\n  );\n\n}\n\nexport function isNegationCue(token: string): boolean {\n  return GROUNDING_NEGATION_TOKENS.has(token) || token.endsWith(\"n't\");\n}\n\nexport function isAttachedNegatedAuxiliary(token: string): boolean {\n  return token.endsWith(\"n't\")\n    || token === \"cannot\"\n    || token === \"cant\"\n    || token === \"can't\";\n}\n\nexport function isNegatedAt(tokens: ReadonlyArray<string>, index: number): boolean {\n  if (tokens[index - 1] === \"only\" && tokens[index - 2] === \"not\") return false;\n  const previousStart = Math.max(0, index - 2);\n  for (let i = previousStart; i < index; i += 1) {\n    if (isNegationCue(tokens[i])) return true;\n  }\n\n  if (tokens[index - 1] === \"than\" && tokens[index - 2] === \"rather\") return true;\n  if (tokens[index - 1] === \"of\" && tokens[index - 2] === \"instead\") return true;\n\n  const next = tokens[index + 1];\n  if (next !== undefined && isAttachedNegatedAuxiliary(next)) return true;\n  const nextNext = tokens[index + 2];\n  return next !== undefined\n    && nextNext !== undefined\n    && GROUNDING_AUXILIARY_TOKENS.has(next)\n    && isNegationCue(nextNext);\n}\n\nexport const GROUNDING_MIN_SHARED_TOKENS = 2;\nexport const GROUNDING_MIN_COVERAGE = 0.5;\n\nexport function stemToken(token: string, preserveTerminalS = false): string {\n  if (token.endsWith(\"'s\")) return token.slice(0, -2);\n  if (preserveTerminalS) return token;\n  if (token.length > 5 && token.endsWith(\"ing\")) {\n    const stem = token.slice(0, -3);\n    return /(.)\\1$/u.test(stem) ? stem.slice(0, -1) : stem;\n  }\n  if (token.length > 4 && token.endsWith(\"ed\")) return token.slice(0, -2);\n  if (\n    !preserveTerminalS\n    && token.length > 3\n    && token.endsWith(\"s\")\n    && !token.endsWith(\"ss\")\n    && GROUNDING_COMMON_VERB_FORMS.has(token)\n  ) {\n    return token.slice(0, -1);\n  }\n  return token;\n}\n\n\nexport function tokenize(text: string): Set<string> {\n  const tokens = new Set<string>();\n  for (const { token, preserveTerminalS } of groundingLexemes(text)) {\n    if (GROUNDING_STOPWORDS[token] !== true) tokens.add(stemToken(token, preserveTerminalS));\n  }\n  return tokens;\n}\n\nexport function normalizeForExactMatch(text: string): string {\n  return text.normalize(\"NFKC\").toLocaleLowerCase().replace(/\\s+/gu, \" \").trim();\n}\n\nexport function sourceSentences(source: string): string[] {\n  const sentences: string[] = [];\n  let sentenceStart = 0;\n  for (let index = 0; index < source.length; index += 1) {\n    const character = source[index];\n    const nextCharacter = source[index + 1];\n    const boundary = character === \"!\"\n      || character === \"?\"\n      || character === \";\"\n      || character === \"\\n\"\n      || (character === \".\" && (\n        nextCharacter === undefined\n        || /\\s/u.test(nextCharacter)\n        || /[\"')\\]}]/u.test(nextCharacter)\n      ));\n    if (!boundary) continue;\n    let sentenceEnd = character === \"\\n\" ? index : index + 1;\n    while (/[.!?;\\n]/u.test(source[sentenceEnd] ?? \"\")) sentenceEnd += 1;\n    const sentence = source.slice(sentenceStart, sentenceEnd).trim();\n    if (sentence.length > 0) sentences.push(sentence);\n    sentenceStart = sentenceEnd;\n    index = sentenceEnd - 1;\n  }\n  const trailingSentence = source.slice(sentenceStart).trim();\n  if (trailingSentence.length > 0) sentences.push(trailingSentence);\n  return sentences.length > 0 ? sentences : [source];\n}\n\n\nexport function groundingTokenSequence(text: string): string[] {\n  let lexemes = groundingLexemes(text);\n  while (lexemes.length > 0 && GROUNDING_AUXILIARY_TOKENS.has(lexemes[0]!.token)) {\n    lexemes = lexemes.slice(1);\n  }\n  return lexemes\n    .filter(({ token }) => GROUNDING_STOPWORDS[token] !== true)\n    .map(({ token, preserveTerminalS }) => stemToken(token, preserveTerminalS));\n}\nexport function normalizedGroundingAlignmentTokenSequence(text: string): string[] {\n  const normalized = normalizedGroundingTokenSequence(text);\n  const firstLexeme = groundingLexemes(text)[0];\n  if (firstLexeme === undefined || !GROUNDING_SUBJECT_PRONOUNS.has(firstLexeme.token)) {\n    return normalized;\n  }\n  return [stemToken(firstLexeme.token, firstLexeme.preserveTerminalS), ...normalized];\n}\n\n\nexport function normalizedGroundingTokenSequence(text: string): string[] {\n  return groundingTokenSequence(text).map((token) => token.replace(/'$/u, \"\"));\n}\n\nexport function areGroundingTokensCompatible(left: string, right: string): boolean {\n  return left === right || `${left}e` === right || left === `${right}e`;\n}\nconst GROUNDING_DENIAL_REPORTING_VERBS = new Set([\n  \"deny\",\n  \"denied\",\n  \"denies\",\n  \"denying\",\n  \"dispute\",\n  \"disputed\",\n  \"disputes\",\n  \"disputing\",\n  \"reject\",\n  \"rejected\",\n  \"rejects\",\n  \"rejecting\",\n  \"refute\",\n  \"refuted\",\n  \"refutes\",\n  \"refuting\",\n  \"contradict\",\n  \"contradicted\",\n  \"contradicts\",\n  \"contradicting\",\n  \"disprove\",\n  \"disproved\",\n  \"disproves\",\n  \"disproving\",\n]);\n\nfunction isDenialReportingVerb(token: string): boolean {\n  return GROUNDING_DENIAL_REPORTING_VERBS.has(token);\n}\nconst GROUNDING_NON_ASSERTIVE_REPORTING_VERBS = new Set([\n  \"allege\",\n  \"alleged\",\n  \"alleges\",\n  \"alleging\",\n  \"allegedly\",\n  \"assert\",\n  \"asserted\",\n  \"asserts\",\n  \"asserting\",\n  \"believe\",\n  \"believed\",\n  \"believes\",\n  \"believing\",\n  \"claim\",\n  \"claimed\",\n  \"claims\",\n  \"claiming\",\n  \"doubt\",\n  \"doubted\",\n  \"doubts\",\n  \"doubting\",\n  \"uncertain\",\n  \"unsure\",\n  \"unclear\",\n  \"unknown\",\n  \"possibly\",\n  \"probably\",\n  \"imagine\",\n  \"imagined\",\n  \"imagines\",\n  \"imagining\",\n  \"report\",\n  \"reported\",\n  \"reports\",\n  \"reporting\",\n  \"reportedly\",\n  \"say\",\n  \"said\",\n  \"says\",\n  \"saying\",\n  \"speculate\",\n  \"speculated\",\n  \"speculates\",\n  \"speculating\",\n  \"suspect\",\n  \"suspected\",\n  \"suspects\",\n  \"suspecting\",\n  \"suppose\",\n  \"supposed\",\n  \"supposes\",\n  \"supposing\",\n  \"supposedly\",\n  \"think\",\n  \"thought\",\n  \"thinks\",\n  \"thinking\",\n]);\n\nfunction isNonAssertiveReportingVerb(token: string): boolean {\n  return GROUNDING_NON_ASSERTIVE_REPORTING_VERBS.has(token);\n}\n\nfunction isGroundingClauseBoundary(token: string): boolean {\n  return token === \"and\"\n    || token === \"but\"\n    || token === \"or\"\n    || token === \"while\"\n    || token === \"although\"\n    || token === \"because\";\n}\n\nfunction isNonAssertiveReportingAt(tokens: ReadonlyArray<string>, index: number): boolean {\n  let boundary = 0;\n  for (let cursor = 0; cursor < index; cursor += 1) {\n    if (isGroundingClauseBoundary(tokens[cursor]!)) boundary = cursor + 1;\n  }\n  for (let cursor = index - 1; cursor >= boundary; cursor -= 1) {\n    if (\n      tokens[cursor] === \"that\"\n      && cursor > boundary\n      && isNonAssertiveReportingVerb(tokens[cursor - 1]!)\n    ) {\n      return true;\n    }\n    if (isNonAssertiveReportingVerb(tokens[cursor]!) && index - cursor <= 5) return true;\n  }\n  return false;\n}\n\nfunction isDeniedAt(tokens: ReadonlyArray<string>, index: number): boolean {\n  let boundary = 0;\n  for (let cursor = 0; cursor < index; cursor += 1) {\n    if (isGroundingClauseBoundary(tokens[cursor]!)) boundary = cursor + 1;\n  }\n  for (let cursor = index - 1; cursor >= boundary; cursor -= 1) {\n    const token = tokens[cursor];\n    if (token === \"that\" && cursor > boundary && isDenialReportingVerb(tokens[cursor - 1]!)) {\n      return true;\n    }\n    if (isDenialReportingVerb(token) && index - cursor <= 5) return true;\n  }\n  return false;\n}\n\nexport function hasContradictoryPolarity(candidate: string, source: string): boolean {\n  const candidateLexemes = groundingLexemes(candidate);\n  const candidateTokens = candidateLexemes.map(({ token }) => token);\n  let coherentContradiction = false;\n  for (const clause of sourceSentences(source).flatMap((sentence) =>\n    sentence.split(/\\s+(?:and|but|or|while|although|because)\\s+/gu))) {\n    const sourceLexemes = groundingLexemes(clause);\n    const sourceTokens = sourceLexemes.map(({ token }) => token);\n    let sourceCursor = 0;\n    let allTokensFound = true;\n    let contradiction = false;\n    for (const [candidateIndex, candidateToken] of candidateTokens.entries()) {\n      if (GROUNDING_STOPWORDS[candidateToken] === true) continue;\n      const sourceIndex = sourceTokens.findIndex(\n        (sourceToken, index) =>\n          index >= sourceCursor\n          && stemToken(sourceToken, sourceLexemes[index]?.preserveTerminalS === true)\n            === stemToken(candidateToken, candidateLexemes[candidateIndex]?.preserveTerminalS === true),\n      );\n      if (sourceIndex === -1) {\n        allTokensFound = false;\n        break;\n      }\n      const candidateNegated = isNegatedAt(candidateTokens, candidateIndex)\n        || isDeniedAt(candidateTokens, candidateIndex);\n      const sourceNegated = isNegatedAt(sourceTokens, sourceIndex)\n        || isDeniedAt(sourceTokens, sourceIndex);\n      const candidateNonAssertive = isNonAssertiveReportingAt(candidateTokens, candidateIndex);\n      const sourceNonAssertive = isNonAssertiveReportingAt(sourceTokens, sourceIndex);\n      if (\n        candidateNegated !== sourceNegated\n        || candidateNonAssertive !== sourceNonAssertive\n      ) {\n        contradiction = true;\n      }\n      sourceCursor = sourceIndex + 1;\n    }\n    if (allTokensFound) {\n      if (!contradiction) return false;\n      coherentContradiction = true;\n    }\n  }\n  if (coherentContradiction) return true;\n\n  const sourceLexemes = groundingLexemes(source);\n  const sourceTokens = sourceLexemes.map(({ token }) => token);\n  const sourcePositions = new Map<string, number[]>();\n  sourceLexemes.forEach(({ token, preserveTerminalS }, index) => {\n    const key = stemToken(token, preserveTerminalS);\n    const positions = sourcePositions.get(key);\n    if (positions) positions.push(index);\n    else sourcePositions.set(key, [index]);\n  });\n  for (const [candidateIndex, token] of candidateTokens.entries()) {\n    if (GROUNDING_STOPWORDS[token] === true) continue;\n    const positions = sourcePositions.get(\n      stemToken(token, candidateLexemes[candidateIndex]?.preserveTerminalS === true),\n    );\n    if (!positions || positions.length === 0) continue;\n    const sourceIndex = positions[positions.length - 1];\n    const candidateNegated = isNegatedAt(candidateTokens, candidateIndex)\n      || isDeniedAt(candidateTokens, candidateIndex);\n    const sourceNegated = isNegatedAt(sourceTokens, sourceIndex)\n      || isDeniedAt(sourceTokens, sourceIndex);\n    const candidateNonAssertive = isNonAssertiveReportingAt(candidateTokens, candidateIndex);\n    const sourceNonAssertive = isNonAssertiveReportingAt(sourceTokens, sourceIndex);\n    if (\n      candidateNegated !== sourceNegated\n      || candidateNonAssertive !== sourceNonAssertive\n    ) {\n      return true;\n    }\n  }\n  return false;\n}\n"],"mappings":"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","names":["sourceLexemes","sourceTokens"]}