chinese-summary 1.0.0

package/dist/chinese-summary.mjs

@@ -0,0 +1,596 @@
+// src/chinese-summary.ts
+var DEFAULT_OPTIONS = {
+  sentenceCount: 3,
+  compressionLevel: 3,
+  ngramSize: 2,
+  dampingFactor: 0.85,
+  maxIterations: 30,
+  convergenceThreshold: 1e-4,
+  weightFirstSentence: 1.5,
+  weightFirstParagraph: 1.2,
+  weightParagraphStart: 1.1,
+  weightParagraphEnd: 1.05,
+  minSentenceLength: 5,
+  minClauseLength: 3,
+  maxClauses: 3,
+  mmrLambda: 0.7,
+  keywordWeight: 1.2
+};
+function clampInt(value, min, max, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.max(min, Math.min(max, Math.floor(value)));
+}
+function clampFloat(value, min, max, fallback) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return fallback;
+  return Math.max(min, Math.min(max, value));
+}
+function sanitizeCompressionLevel(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    const clamped = Math.max(1, Math.min(5, Math.floor(value)));
+    return clamped;
+  }
+  return 3;
+}
+function sanitizeOptions(options) {
+  return {
+    sentenceCount: clampInt(options.sentenceCount, 1, 100, DEFAULT_OPTIONS.sentenceCount),
+    compressionLevel: sanitizeCompressionLevel(options.compressionLevel),
+    ngramSize: clampInt(options.ngramSize, 1, 5, DEFAULT_OPTIONS.ngramSize),
+    dampingFactor: clampFloat(options.dampingFactor, 0.1, 0.95, DEFAULT_OPTIONS.dampingFactor),
+    maxIterations: clampInt(options.maxIterations, 1, 200, DEFAULT_OPTIONS.maxIterations),
+    convergenceThreshold: clampFloat(options.convergenceThreshold, 1e-8, 1, DEFAULT_OPTIONS.convergenceThreshold),
+    weightFirstSentence: clampFloat(options.weightFirstSentence, 0.5, 5, DEFAULT_OPTIONS.weightFirstSentence),
+    weightFirstParagraph: clampFloat(options.weightFirstParagraph, 0.5, 5, DEFAULT_OPTIONS.weightFirstParagraph),
+    weightParagraphStart: clampFloat(options.weightParagraphStart, 0.5, 5, DEFAULT_OPTIONS.weightParagraphStart),
+    weightParagraphEnd: clampFloat(options.weightParagraphEnd, 0.5, 5, DEFAULT_OPTIONS.weightParagraphEnd),
+    minSentenceLength: clampInt(options.minSentenceLength, 1, 100, DEFAULT_OPTIONS.minSentenceLength),
+    minClauseLength: clampInt(options.minClauseLength, 1, 50, DEFAULT_OPTIONS.minClauseLength),
+    maxClauses: clampInt(options.maxClauses, 1, 20, DEFAULT_OPTIONS.maxClauses),
+    mmrLambda: clampFloat(options.mmrLambda, 0.3, 1, DEFAULT_OPTIONS.mmrLambda),
+    keywordWeight: clampFloat(options.keywordWeight, 0, 5, DEFAULT_OPTIONS.keywordWeight)
+  };
+}
+function safeNumber(value, fallback = 0) {
+  return Number.isFinite(value) ? value : fallback;
+}
+var SENTENCE_ENDINGS = /[。！？；\n\r]/;
+var TRAILING_QUOTES = /[」』""”）】》'']/;
+function splitSentences(text, minLength) {
+  const sentences = [];
+  const paragraphs = text.split(/[\n\r]+/).filter((p) => p.trim().length > 0);
+  let globalIndex = 0;
+  for (let pi = 0; pi < paragraphs.length; pi++) {
+    const para = paragraphs[pi].trim();
+    if (para.length === 0) continue;
+    const rawSentences = [];
+    let current = "";
+    for (let i = 0; i < para.length; i++) {
+      current += para[i];
+      if (SENTENCE_ENDINGS.test(para[i])) {
+        while (i + 1 < para.length && TRAILING_QUOTES.test(para[i + 1])) {
+          i++;
+          current += para[i];
+        }
+        const trimmed = current.trim();
+        if (trimmed.length > 0) {
+          rawSentences.push(trimmed);
+        }
+        current = "";
+      }
+    }
+    if (current.trim().length > 0) {
+      rawSentences.push(current.trim());
+    }
+    for (let si = 0; si < rawSentences.length; si++) {
+      const s = rawSentences[si];
+      if (s.length < minLength) continue;
+      sentences.push({
+        index: globalIndex++,
+        text: s,
+        paragraphIndex: pi,
+        sentenceInParagraph: si,
+        isParagraphStart: si === 0,
+        isParagraphEnd: si === rawSentences.length - 1,
+        isFirstParagraph: pi === 0,
+        score: 0
+      });
+    }
+  }
+  return sentences;
+}
+function extractNgrams(text, n) {
+  const ngrams = /* @__PURE__ */ new Set();
+  if (!text || text.length === 0) return ngrams;
+  const cleaned = text.replace(/[^\u4e00-\u9fff\u3400-\u4dbf\u3007a-zA-Z0-9]/g, "");
+  if (cleaned.length < n) return ngrams;
+  for (let i = 0; i <= cleaned.length - n; i++) {
+    ngrams.add(cleaned.substring(i, i + n));
+  }
+  return ngrams;
+}
+var STOP_CHARS = new Set("\u7684\u4E86\u662F\u5728\u6211\u6709\u548C\u5C31\u4E0D\u4EBA\u90FD\u4E00\u8FD9\u4E2D\u5927\u4E3A\u4E0A\u4E2A\u56FD\u4E5F\u5B50\u65F6\u9053\u8BF4\u51FA\u4F1A\u8981\u6CA1\u6210\u597D\u80FD\u5BF9\u7136\u5979\u8FC7\u751F\u91CC\u540E\u4EE5\u5230\u53BB\u80FD\u5F97\u7740\u5E74\u8FD9".split(""));
+function extractKeywords(sentences, topK) {
+  if (sentences.length === 0) return /* @__PURE__ */ new Set();
+  const tf = /* @__PURE__ */ new Map();
+  const df = /* @__PURE__ */ new Map();
+  for (const sent of sentences) {
+    const cleaned = sent.text.replace(/[^\u4e00-\u9fff\u3400-\u4dbf]/g, "");
+    const seen = /* @__PURE__ */ new Set();
+    for (const ch of cleaned) {
+      if (STOP_CHARS.has(ch)) continue;
+      tf.set(ch, (tf.get(ch) || 0) + 1);
+      if (!seen.has(ch)) {
+        df.set(ch, (df.get(ch) || 0) + 1);
+        seen.add(ch);
+      }
+    }
+  }
+  const n = sentences.length;
+  const tfidf = /* @__PURE__ */ new Map();
+  for (const [ch, freq] of tf) {
+    const docFreq = df.get(ch) || 1;
+    const idf = Math.log((n + 1) / (docFreq + 1)) + 1;
+    tfidf.set(ch, freq * idf);
+  }
+  const sorted = [...tfidf.entries()].sort((a, b) => b[1] - a[1]).slice(0, topK);
+  return new Set(sorted.map(([ch]) => ch));
+}
+function keywordWeightForSentence(sentence, keywords, keywordWeight) {
+  if (keywords.size === 0 || keywordWeight === 0) return 1;
+  const cleaned = sentence.text.replace(/[^\u4e00-\u9fff\u3400-\u4dbf]/g, "");
+  let hits = 0;
+  for (const ch of cleaned) {
+    if (keywords.has(ch)) hits++;
+  }
+  if (hits === 0) return 1;
+  const ratio = hits / keywords.size;
+  return Math.pow(keywordWeight, Math.min(ratio, 1));
+}
+function similarity(ngramsA, ngramsB) {
+  if (ngramsA.size === 0 || ngramsB.size === 0) return 0;
+  let intersection = 0;
+  for (const gram of ngramsA) {
+    if (ngramsB.has(gram)) intersection++;
+  }
+  if (intersection === 0) return 0;
+  const denom = Math.log(ngramsA.size + 1) + Math.log(ngramsB.size + 1);
+  if (denom === 0) return 0;
+  return safeNumber(intersection / denom);
+}
+function positionWeight(sentence, opts) {
+  let weight = 1;
+  if (sentence.isFirstParagraph && sentence.isParagraphStart) {
+    weight *= opts.weightFirstSentence;
+  } else if (sentence.isFirstParagraph) {
+    weight *= opts.weightFirstParagraph;
+  }
+  if (!sentence.isFirstParagraph && sentence.isParagraphStart) {
+    weight *= opts.weightParagraphStart;
+  }
+  if (sentence.isParagraphEnd) {
+    weight *= opts.weightParagraphEnd;
+  }
+  return safeNumber(weight, 1);
+}
+function textRank(sentences, ngramSets, opts, keywords) {
+  const n = sentences.length;
+  if (n === 0) return;
+  if (n === 1) {
+    let score = positionWeight(sentences[0], opts);
+    if (keywords && opts.keywordWeight > 0) {
+      score *= keywordWeightForSentence(sentences[0], keywords, opts.keywordWeight);
+    }
+    sentences[0].score = safeNumber(score, 1);
+    return;
+  }
+  const simMatrix = Array.from({ length: n }, () => new Array(n).fill(0));
+  const simSums = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const sim = similarity(ngramSets[i], ngramSets[j]);
+      simMatrix[i][j] = sim;
+      simMatrix[j][i] = sim;
+      simSums[i] += sim;
+      simSums[j] += sim;
+    }
+  }
+  const initScores = sentences.map((s) => {
+    let score = positionWeight(s, opts);
+    if (keywords && opts.keywordWeight > 0) {
+      score *= keywordWeightForSentence(s, keywords, opts.keywordWeight);
+    }
+    return safeNumber(score, 1);
+  });
+  const scores = [...initScores];
+  for (let iter = 0; iter < opts.maxIterations; iter++) {
+    const newScores = new Array(n).fill(0);
+    let maxDiff = 0;
+    for (let i = 0; i < n; i++) {
+      let rankSum = 0;
+      for (let j = 0; j < n; j++) {
+        if (i === j || simSums[j] === 0) continue;
+        rankSum += simMatrix[i][j] / simSums[j] * scores[j];
+      }
+      newScores[i] = (1 - opts.dampingFactor) * initScores[i] + opts.dampingFactor * rankSum;
+      newScores[i] = safeNumber(newScores[i], initScores[i]);
+      const diff = Math.abs(newScores[i] - scores[i]);
+      if (diff > maxDiff) maxDiff = diff;
+    }
+    for (let i = 0; i < n; i++) {
+      scores[i] = newScores[i];
+    }
+    if (maxDiff < opts.convergenceThreshold) break;
+  }
+  for (let i = 0; i < n; i++) {
+    sentences[i].score = safeNumber(scores[i], initScores[i]);
+  }
+}
+function sentenceCountForLevel(totalSentences, level) {
+  if (level === 5) return totalSentences;
+  if (level === 4) return Math.max(3, Math.ceil(totalSentences * 0.5));
+  if (level === 3) return Math.max(3, Math.ceil(totalSentences * 0.3));
+  if (level === 2) return Math.max(2, Math.ceil(totalSentences * 0.2));
+  return 1;
+}
+function selectByMMR(sentences, ngramSets, targetCount, lambda) {
+  if (sentences.length <= targetCount) return [...sentences];
+  const scores = sentences.map((s) => s.score);
+  const maxScore = Math.max(...scores);
+  const minScore = Math.min(...scores);
+  const scoreRange = maxScore - minScore || 1;
+  const normalizedScores = scores.map((s) => (s - minScore) / scoreRange);
+  const selected = [];
+  const remaining = new Set(sentences.map((_, i) => i));
+  let bestIdx = -1;
+  let bestScore = -Infinity;
+  for (let i = 0; i < sentences.length; i++) {
+    if (normalizedScores[i] > bestScore) {
+      bestScore = normalizedScores[i];
+      bestIdx = i;
+    }
+  }
+  selected.push(bestIdx);
+  remaining.delete(bestIdx);
+  while (selected.length < targetCount && remaining.size > 0) {
+    let bestMMR = -Infinity;
+    let bestCandidate = -1;
+    for (const idx of remaining) {
+      const relevance = lambda * normalizedScores[idx];
+      let maxSim = 0;
+      for (const selIdx of selected) {
+        const sim = similarity(ngramSets[idx], ngramSets[selIdx]);
+        if (sim > maxSim) maxSim = sim;
+      }
+      const diversity = (1 - lambda) * maxSim;
+      const mmr = relevance - diversity;
+      if (mmr > bestMMR) {
+        bestMMR = mmr;
+        bestCandidate = idx;
+      }
+    }
+    if (bestCandidate === -1) break;
+    selected.push(bestCandidate);
+    remaining.delete(bestCandidate);
+  }
+  return selected.map((idx) => sentences[idx]);
+}
+var CLAUSE_SEPARATORS = /[，、,；;：:]/;
+function splitClauses(sentence, minLength) {
+  if (!sentence || sentence.length === 0) return [];
+  const clauses = [];
+  let current = "";
+  for (let i = 0; i < sentence.length; i++) {
+    current += sentence[i];
+    if (CLAUSE_SEPARATORS.test(sentence[i])) {
+      const trimmed = current.trim();
+      if (trimmed.length >= minLength) {
+        clauses.push(trimmed);
+      }
+      current = "";
+    }
+  }
+  const remaining = current.trim();
+  if (remaining.length >= minLength) {
+    clauses.push(remaining);
+  }
+  return clauses;
+}
+var MAIN_CLAUSE_BOOST = 1.3;
+function clauseTextRank(clauses, ngramSets, opts) {
+  const n = clauses.length;
+  if (n === 0) return;
+  if (n === 1) {
+    clauses[0].score = safeNumber(clauses[0].score, 1);
+    return;
+  }
+  const simMatrix = Array.from({ length: n }, () => new Array(n).fill(0));
+  const simSums = new Array(n).fill(0);
+  for (let i = 0; i < n; i++) {
+    for (let j = i + 1; j < n; j++) {
+      const sim = similarity(ngramSets[i], ngramSets[j]);
+      simMatrix[i][j] = sim;
+      simMatrix[j][i] = sim;
+      simSums[i] += sim;
+      simSums[j] += sim;
+    }
+  }
+  const initScores = clauses.map((c) => {
+    const base = c.score || 1;
+    return c.isMainClause ? base * MAIN_CLAUSE_BOOST : base;
+  });
+  const scores = [...initScores];
+  for (let iter = 0; iter < opts.maxIterations; iter++) {
+    const newScores = new Array(n).fill(0);
+    let maxDiff = 0;
+    for (let i = 0; i < n; i++) {
+      let rankSum = 0;
+      for (let j = 0; j < n; j++) {
+        if (i === j || simSums[j] === 0) continue;
+        rankSum += simMatrix[i][j] / simSums[j] * scores[j];
+      }
+      newScores[i] = (1 - opts.dampingFactor) * initScores[i] + opts.dampingFactor * rankSum;
+      newScores[i] = safeNumber(newScores[i], initScores[i]);
+      const diff = Math.abs(newScores[i] - scores[i]);
+      if (diff > maxDiff) maxDiff = diff;
+    }
+    for (let i = 0; i < n; i++) {
+      scores[i] = newScores[i];
+    }
+    if (maxDiff < opts.convergenceThreshold) break;
+  }
+  for (let i = 0; i < n; i++) {
+    clauses[i].score = safeNumber(scores[i], initScores[i]);
+  }
+}
+function rerankSentences(sentences, targetCount, opts, keywords) {
+  const ngramSets = sentences.map((s) => extractNgrams(s.text, opts.ngramSize));
+  textRank(sentences, ngramSets, opts, keywords);
+  const firstPassCount = Math.max(5, targetCount * 2);
+  const firstPass = [...sentences].sort((a, b) => b.score - a.score).slice(0, Math.min(firstPassCount, sentences.length));
+  if (firstPass.length <= targetCount) {
+    return firstPass;
+  }
+  const secondPassSentences = firstPass.map((s, i) => ({
+    ...s,
+    index: i
+  }));
+  const secondNgramSets = secondPassSentences.map(
+    (s) => extractNgrams(s.text, opts.ngramSize)
+  );
+  textRank(secondPassSentences, secondNgramSets, opts);
+  const result = [...secondPassSentences].sort((a, b) => b.score - a.score).slice(0, targetCount);
+  return result.map((s) => {
+    const original = firstPass.find((f) => f.text === s.text);
+    return original || s;
+  });
+}
+var SENTENCE_FINAL_PUNCT = /[。！？；!?;]$/;
+function joinClauses(clauses) {
+  if (clauses.length === 0) return "";
+  if (clauses.length === 1) return clauses[0];
+  let result = clauses[0];
+  for (let i = 1; i < clauses.length; i++) {
+    const prev = result;
+    const curr = clauses[i];
+    const lastChar = prev[prev.length - 1];
+    if (SENTENCE_FINAL_PUNCT.test(prev)) {
+      result = result + " " + curr;
+    } else if (CLAUSE_SEPARATORS.test(lastChar)) {
+      result = result + curr;
+    } else {
+      result = result + "\uFF0C" + curr;
+    }
+  }
+  return result;
+}
+var CLAUSE_CONJUNCTIONS = [
+  // 转折
+  "\u4F46",
+  "\u4F46\u662F",
+  "\u7136\u800C",
+  "\u4E0D\u8FC7",
+  "\u53EF\u662F",
+  "\u5374",
+  "\u53CD\u800C",
+  "\u53EA\u662F",
+  // 递进/并列
+  "\u4E5F",
+  "\u800C\u4E14",
+  "\u5E76\u4E14",
+  "\u6B64\u5916",
+  "\u53E6\u5916",
+  "\u540C\u65F6",
+  "\u65E2",
+  "\u53C8",
+  // 因果
+  "\u56E0\u6B64",
+  "\u6240\u4EE5",
+  "\u4E8E\u662F",
+  "\u4ECE\u800C",
+  "\u8FDB\u800C",
+  "\u6545",
+  // 让步
+  "\u867D\u7136",
+  "\u5C3D\u7BA1",
+  "\u56FA\u7136",
+  "\u5373\u4F7F",
+  "\u5C31\u7B97",
+  // 条件
+  "\u5982\u679C",
+  "\u5047\u5982",
+  "\u53EA\u8981",
+  "\u53EA\u6709",
+  "\u9664\u975E",
+  // 总结
+  "\u603B\u4E4B",
+  "\u7EFC\u4E0A",
+  "\u7531\u6B64\u53EF\u89C1",
+  "\u603B\u7684\u6765\u8BF4"
+];
+var MAX_CONJ_LEN = Math.max(...CLAUSE_CONJUNCTIONS.map((c) => c.length));
+function processConjunctions(orderedClauses, allClauses) {
+  const clauseMap = /* @__PURE__ */ new Map();
+  for (const c of allClauses) {
+    clauseMap.set(c.sourceSentenceIndex + ":" + c.clauseIndex, c);
+  }
+  const selectedSet = new Set(orderedClauses.map((c) => c.sourceSentenceIndex + ":" + c.clauseIndex));
+  const results = [];
+  for (const clause of orderedClauses) {
+    let text = clause.text;
+    const matchedConj = matchConjunction(text);
+    if (matchedConj) {
+      const prevKey = clause.sourceSentenceIndex + ":" + (clause.clauseIndex - 1);
+      const prevClause = clauseMap.get(prevKey);
+      if (prevClause && selectedSet.has(prevKey)) {
+      } else {
+        text = text.substring(matchedConj.length);
+        text = text.replace(/^[，、,；;：:\s]+/, "");
+      }
+    }
+    if (text.length > 0) {
+      results.push(text);
+    }
+  }
+  return results;
+}
+function matchConjunction(text) {
+  for (let len = MAX_CONJ_LEN; len >= 1; len--) {
+    if (len > text.length) continue;
+    const prefix = text.substring(0, len);
+    if (CLAUSE_CONJUNCTIONS.includes(prefix)) {
+      return prefix;
+    }
+  }
+  return null;
+}
+function extractClauseSummary(sentences, opts, keywords) {
+  const ngramSets = sentences.map((s) => extractNgrams(s.text, opts.ngramSize));
+  textRank(sentences, ngramSets, opts, keywords);
+  const topSentenceCount = Math.min(5, sentences.length);
+  const topSentences = [...sentences].sort((a, b) => b.score - a.score).slice(0, topSentenceCount);
+  const allClauses = [];
+  for (const sent of topSentences) {
+    const rawClauses = splitClauses(sent.text, opts.minClauseLength);
+    for (let ci = 0; ci < rawClauses.length; ci++) {
+      allClauses.push({
+        text: rawClauses[ci],
+        sourceSentenceIndex: sent.index,
+        clauseIndex: ci,
+        isMainClause: ci === 0,
+        // 第一个子句是主干子句
+        score: sent.score
+      });
+    }
+  }
+  if (allClauses.length === 0) {
+    const best = topSentences[0];
+    return {
+      summary: [best.text],
+      clauses: [{
+        text: best.text,
+        sourceSentenceIndex: best.index,
+        clauseIndex: 0,
+        isMainClause: true,
+        score: best.score
+      }]
+    };
+  }
+  const clauseNgramSets = allClauses.map(
+    (c) => extractNgrams(c.text, opts.ngramSize)
+  );
+  clauseTextRank(allClauses, clauseNgramSets, opts);
+  const maxClauses = Math.min(opts.maxClauses, allClauses.length);
+  const topClauses = [...allClauses].sort((a, b) => b.score - a.score).slice(0, maxClauses);
+  const orderedClauses = [...topClauses].sort((a, b) => {
+    if (a.sourceSentenceIndex !== b.sourceSentenceIndex) {
+      return a.sourceSentenceIndex - b.sourceSentenceIndex;
+    }
+    return a.clauseIndex - b.clauseIndex;
+  });
+  const processedTexts = processConjunctions(orderedClauses, allClauses);
+  const summaryText = joinClauses(processedTexts);
+  return {
+    summary: [summaryText],
+    clauses: allClauses
+  };
+}
+function extractSummary(text, options = {}) {
+  if (text === null || text === void 0) {
+    return { summary: [], sentences: [], text: "", compressionLevel: 3 };
+  }
+  if (typeof text !== "string") {
+    try {
+      text = String(text);
+    } catch {
+      return { summary: [], sentences: [], text: "", compressionLevel: 3 };
+    }
+  }
+  text = text.replace(/[\uFEFF\u200B\u200C\u200D\u00AD]/g, "");
+  text = text.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+  if (text.trim().length === 0) {
+    return { summary: [], sentences: [], text: "", compressionLevel: 3 };
+  }
+  const opts = sanitizeOptions(options);
+  const level = opts.compressionLevel;
+  const sentences = splitSentences(text, opts.minSentenceLength);
+  if (sentences.length === 0) {
+    return { summary: [], sentences: [], text: "", compressionLevel: level };
+  }
+  const keywords = opts.keywordWeight > 0 ? extractKeywords(sentences, Math.min(20, Math.max(5, Math.ceil(sentences.length * 0.5)))) : void 0;
+  if (level === 5) {
+    const ngramSets2 = sentences.map((s) => extractNgrams(s.text, opts.ngramSize));
+    textRank(sentences, ngramSets2, opts, keywords);
+    const summary2 = sentences.map((s) => s.text);
+    return { summary: summary2, sentences, text: summary2.join(" "), compressionLevel: level };
+  }
+  if (level === 1) {
+    if (sentences.length <= 1) {
+      const summary3 = sentences.map((s) => s.text);
+      return { summary: summary3, sentences, text: summary3.join(" "), compressionLevel: level };
+    }
+    const { summary: summary2, clauses } = extractClauseSummary(sentences, opts, keywords);
+    return { summary: summary2, sentences, text: summary2.join(" "), compressionLevel: level, clauses };
+  }
+  let targetCount;
+  if (options.sentenceCount !== void 0 && options.compressionLevel === void 0) {
+    targetCount = opts.sentenceCount;
+  } else {
+    targetCount = sentenceCountForLevel(sentences.length, level);
+  }
+  if (sentences.length <= targetCount) {
+    const summary2 = sentences.map((s) => s.text);
+    return { summary: summary2, sentences, text: summary2.join(" "), compressionLevel: level };
+  }
+  if (level === 2) {
+    const topSentences = rerankSentences(sentences, targetCount, opts, keywords);
+    const selectedIndices2 = new Set(topSentences.map((s) => s.index));
+    const summary2 = sentences.filter((s) => selectedIndices2.has(s.index)).map((s) => s.text);
+    const ngramSets2 = sentences.map((s) => extractNgrams(s.text, opts.ngramSize));
+    textRank(sentences, ngramSets2, opts, keywords);
+    return { summary: summary2, sentences, text: summary2.join(" "), compressionLevel: level };
+  }
+  const ngramSets = sentences.map((s) => extractNgrams(s.text, opts.ngramSize));
+  textRank(sentences, ngramSets, opts, keywords);
+  const topN = selectByMMR(sentences, ngramSets, targetCount, opts.mmrLambda);
+  const selectedIndices = new Set(topN.map((s) => s.index));
+  const summary = sentences.filter((s) => selectedIndices.has(s.index)).map((s) => s.text);
+  return { summary, sentences, text: summary.join(" "), compressionLevel: level };
+}
+function rankSentences(text, options = {}) {
+  if (text === null || text === void 0 || typeof text !== "string") {
+    return [];
+  }
+  if (text.trim().length === 0) return [];
+  const opts = sanitizeOptions(options);
+  const sentences = splitSentences(text, opts.minSentenceLength);
+  if (sentences.length === 0) return [];
+  const keywords = opts.keywordWeight > 0 ? extractKeywords(sentences, Math.min(20, Math.max(5, Math.ceil(sentences.length * 0.5)))) : void 0;
+  const ngramSets = sentences.map((s) => extractNgrams(s.text, opts.ngramSize));
+  textRank(sentences, ngramSets, opts, keywords);
+  return [...sentences].sort((a, b) => b.score - a.score);
+}
+export {
+  extractSummary,
+  rankSentences
+};
+//# sourceMappingURL=chinese-summary.mjs.map