485 lines
24 KiB
JavaScript
485 lines
24 KiB
JavaScript
// js/sub_block_segmenter.js
|
||
(function SubBlockSegmenter(global) {
|
||
/**
|
||
* 将块级元素内容按标点分割成子块 (span.sub-block)。
|
||
* @param {HTMLElement} blockElement - 要分割的块级元素 (如 p, h1-h6)。
|
||
* @param {string|number} parentBlockIndex - 父块的索引。
|
||
*/
|
||
function segmentBlockIntoSubBlocks(blockElement, parentBlockIndex, force = false) {
|
||
// 性能埋点：分块开始
|
||
performance.mark('subBlock-start');
|
||
// 调试开关：本文件的检测/一致性类日志统一受控
|
||
const __SUBBLOCK_DEBUG__ = (function(){
|
||
try {
|
||
return !!(window && (window.ENABLE_SUBBLOCK_DEBUG || localStorage.getItem('ENABLE_SUBBLOCK_DEBUG') === 'true'));
|
||
} catch { return false; }
|
||
})();
|
||
|
||
// ===== 新增：分割前检测 =====
|
||
const preSubBlocks = Array.from(blockElement.querySelectorAll('.sub-block'));
|
||
if (__SUBBLOCK_DEBUG__ && preSubBlocks.length > 0) {
|
||
console.warn(`[SubBlockSegmenter][检测] 分割前已存在 ${preSubBlocks.length} 个 .sub-block，内容摘要：`, preSubBlocks.map(sb => (sb.textContent || '').substring(0, 30)));
|
||
}
|
||
const preTextContent = blockElement.textContent;
|
||
|
||
// ===== 新增：详细日志 =====
|
||
// console.log(`[SubBlockSegmenter] 开始分块 #${parentBlockIndex}, 元素类型: ${blockElement.tagName}, 内容前20字符: "${(blockElement.textContent || '').substring(0, 20)}..."`);
|
||
|
||
// 检查是否已经有子块，如果有则记录它们
|
||
const existingSubBlocks = blockElement.querySelectorAll('.sub-block');
|
||
if (existingSubBlocks.length > 0) {
|
||
// console.log(`[SubBlockSegmenter] 警告: 块 #${parentBlockIndex} 已有 ${existingSubBlocks.length} 个子块，这些将被重新生成`);
|
||
// console.log(`[SubBlockSegmenter] 现有子块ID列表:`, Array.from(existingSubBlocks).map(sb => sb.dataset.subBlockId));
|
||
}
|
||
|
||
// 优化：只有当文本足够长且包含中文或英文句读符号才进行分块
|
||
const rawText = (blockElement.textContent || '').trim();
|
||
const containsCnPeriod = rawText.indexOf('。') !== -1;
|
||
const containsEnPunct = /[\.!?;:]/.test(rawText);
|
||
// console.log(`[SubBlockSegmenter] 块 #${parentBlockIndex} 文本长度: ${rawText.length}, CN句号: ${containsCnPeriod}, EN标点: ${containsEnPunct}`);
|
||
|
||
// ===== 新增：公式感知检测 =====
|
||
const hasFormula = checkForFormulas(blockElement, rawText);
|
||
if (__SUBBLOCK_DEBUG__ && hasFormula) {
|
||
console.log(`[SubBlockSegmenter] 块 #${parentBlockIndex} 包含数学公式，启用公式感知分割`);
|
||
}
|
||
|
||
// 修改分割条件：包含公式的块使用不同的分割策略
|
||
// 仅当文本很短且也不含中英文句读时才跳过；
|
||
// 只要存在句读符，即使很短也执行分块以支持精确高亮。
|
||
if (!force && !hasFormula && (rawText.length < 80 && (!containsCnPeriod && !containsEnPunct))) {
|
||
// 跳过分割
|
||
// console.log(`[SubBlockSegmenter] 块 #${parentBlockIndex} 不满足分块条件，跳过分块`);
|
||
performance.mark('subBlock-end');
|
||
performance.measure('subBlockSegmentSkipping', 'subBlock-start', 'subBlock-end');
|
||
return;
|
||
}
|
||
|
||
// 如果块元素本身是表格，或者其内部有表格，则不进行分割处理
|
||
if (blockElement.tagName === 'TABLE' || blockElement.querySelector('table')) {
|
||
// console.log(`[SubBlockSegmenter] 块 #${parentBlockIndex} 是表格或包含表格，跳过分块`);
|
||
return; // 直接返回，不修改表格内容
|
||
}
|
||
|
||
// ===== 新增：检测 Markdown 表格语法 =====
|
||
// 检测表格分隔符行：|---|---|... 或 |:---|---:| 等
|
||
const hasMarkdownTableSeparator = /\|(:?-+:?\|)+/.test(rawText);
|
||
if (hasMarkdownTableSeparator) {
|
||
console.log(`[SubBlockSegmenter] 块 #${parentBlockIndex} 包含 Markdown 表格语法，跳过分块以保持表格完整性`);
|
||
return; // 直接返回，不分割 Markdown 表格
|
||
}
|
||
|
||
// ===== 新增：公式感知分割处理 =====
|
||
if (hasFormula) {
|
||
return segmentFormulaAwareBlock(blockElement, parentBlockIndex, rawText, __SUBBLOCK_DEBUG__);
|
||
}
|
||
|
||
// ===== 新增：保存原始内容，用于对比 =====
|
||
const originalContent = blockElement.innerHTML;
|
||
const originalTextContent = blockElement.textContent;
|
||
|
||
let subBlockTrueCounter = 0; // Counter for non-empty sub-blocks
|
||
const newChildNodesContainer = document.createDocumentFragment();
|
||
let firstGeneratedSubBlockElement = null; // Store the first (potentially only) sub-block
|
||
|
||
// Define delimiters: Chinese period or common English sentence punctuation
|
||
// The regex captures the delimiter itself and any trailing whitespace.
|
||
const delimiterRegex = /([。\.!?;:])(\s*)/g;
|
||
|
||
let currentSpanContentNodes = []; // Nodes for the current sub-block being built
|
||
|
||
function flushCurrentSpan(isEndOfBlock = false) {
|
||
if (currentSpanContentNodes.length > 0) {
|
||
const tempSpan = document.createElement('span'); // Temporary span to check if it's empty
|
||
currentSpanContentNodes.forEach(n => tempSpan.appendChild(n.cloneNode(true))); // Use cloned nodes for check
|
||
|
||
if (tempSpan.textContent.trim() !== "" || (isEndOfBlock && tempSpan.innerHTML.trim() !== "")) { // Ensure span is not just whitespace or empty HTML
|
||
const span = document.createElement('span');
|
||
span.className = 'sub-block';
|
||
const subBlockId = `${parentBlockIndex}.${subBlockTrueCounter}`;
|
||
span.dataset.subBlockId = subBlockId; // Corrected template literal
|
||
|
||
// ===== 新增：记录子块内容 =====
|
||
const subBlockContent = tempSpan.textContent;
|
||
// console.log(`[SubBlockSegmenter] 创建子块 #${subBlockId}, 内容前20字符: "${subBlockContent.substring(0, 20)}..."`);
|
||
|
||
currentSpanContentNodes.forEach(n => span.appendChild(n)); // Append original nodes
|
||
newChildNodesContainer.appendChild(span);
|
||
|
||
if (subBlockTrueCounter === 0) { // If this is the first non-empty sub-block
|
||
firstGeneratedSubBlockElement = span;
|
||
} else { // If we've already found one and now found another, it's not the only one
|
||
firstGeneratedSubBlockElement = null; // Invalidate, as there are multiple
|
||
}
|
||
subBlockTrueCounter++;
|
||
} else {
|
||
// console.log(`[SubBlockSegmenter] 跳过空子块 #${parentBlockIndex}.${subBlockTrueCounter}`);
|
||
}
|
||
currentSpanContentNodes = [];
|
||
}
|
||
}
|
||
|
||
function processNodesRecursive(nodes) {
|
||
for (const node of nodes) {
|
||
if (node.nodeType === Node.TEXT_NODE) {
|
||
let text = node.textContent;
|
||
let lastIndex = 0;
|
||
let match;
|
||
if (text.trim() === '' && currentSpanContentNodes.length === 0) { // Skip leading pure whitespace text nodes if current span is empty
|
||
continue;
|
||
}
|
||
while ((match = delimiterRegex.exec(text)) !== null) {
|
||
// Add text before delimiter
|
||
if (match.index > lastIndex) {
|
||
currentSpanContentNodes.push(document.createTextNode(text.substring(lastIndex, match.index)));
|
||
}
|
||
// Add the delimiter itself
|
||
currentSpanContentNodes.push(document.createTextNode(match[1]));
|
||
// Add trailing space if captured
|
||
if (match[2]) {
|
||
currentSpanContentNodes.push(document.createTextNode(match[2]));
|
||
}
|
||
flushCurrentSpan(); // End of a sub-block
|
||
lastIndex = match.index + match[0].length;
|
||
}
|
||
// Add remaining text after the last delimiter
|
||
if (lastIndex < text.length) {
|
||
currentSpanContentNodes.push(document.createTextNode(text.substring(lastIndex)));
|
||
}
|
||
} else if (node.nodeType === Node.ELEMENT_NODE) {
|
||
// For inline elements, clone them and add to current span content.
|
||
currentSpanContentNodes.push(node.cloneNode(true));
|
||
} else {
|
||
// Other node types (comments, etc.), clone and add.
|
||
currentSpanContentNodes.push(node.cloneNode(true));
|
||
}
|
||
}
|
||
}
|
||
|
||
processNodesRecursive(Array.from(blockElement.childNodes));
|
||
flushCurrentSpan(true); // Flush any remaining content, isEndOfBlock = true
|
||
|
||
// ===== 新增：对比分块前后的内容 =====
|
||
// console.log(`[SubBlockSegmenter] 块 #${parentBlockIndex} 分块前文本长度: ${originalTextContent.length}`);
|
||
|
||
// Clear original content and append new sub-block spans
|
||
blockElement.innerHTML = '';
|
||
blockElement.appendChild(newChildNodesContainer);
|
||
|
||
// ===== 新增：分割后检测 =====
|
||
const postSubBlocks = Array.from(blockElement.querySelectorAll('.sub-block'));
|
||
const postTextContent = blockElement.textContent;
|
||
if (preSubBlocks.length > 0) {
|
||
if (__SUBBLOCK_DEBUG__ && postSubBlocks.length < preSubBlocks.length) {
|
||
console.error(`[SubBlockSegmenter][检测] 分割后子块数量变少！分割前: ${preSubBlocks.length}，分割后: ${postSubBlocks.length}`);
|
||
console.error(`[SubBlockSegmenter][检测] 分割前内容摘要:`, preSubBlocks.map(sb => (sb.textContent || '').substring(0, 30)));
|
||
console.error(`[SubBlockSegmenter][检测] 分割后内容摘要:`, postSubBlocks.map(sb => (sb.textContent || '').substring(0, 30)));
|
||
}
|
||
// 检查内容拼接（如前后内容合并到一个 span）
|
||
if (__SUBBLOCK_DEBUG__ && postSubBlocks.length === 1 && preSubBlocks.length > 1) {
|
||
const mergedContent = postSubBlocks[0].textContent || '';
|
||
const preConcat = preSubBlocks.map(sb => sb.textContent || '').join('');
|
||
if (mergedContent.replace(/\s+/g, '') === preConcat.replace(/\s+/g, '')) {
|
||
console.error(`[SubBlockSegmenter][检测] 分割后所有内容被合并到一个子块！内容：${mergedContent.substring(0, 50)}...`);
|
||
}
|
||
}
|
||
}
|
||
if (postSubBlocks.length > 0) {
|
||
// 检查是否有异常长的子块（仅在开启调试时输出）
|
||
const maxLen = Math.max(...postSubBlocks.map(sb => (sb.textContent || '').length));
|
||
if (__SUBBLOCK_DEBUG__ && maxLen > 500 && postSubBlocks.length > 1) {
|
||
console.warn(`[SubBlockSegmenter][检测] 存在异常长的子块，长度: ${maxLen}`);
|
||
}
|
||
}
|
||
|
||
// ===== 新增：验证分块后的内容完整性 =====
|
||
const newTextContent = blockElement.textContent;
|
||
// console.log(`[SubBlockSegmenter] 块 #${parentBlockIndex} 分块后文本长度: ${newTextContent.length}`);
|
||
|
||
if (__SUBBLOCK_DEBUG__ && originalTextContent.trim() !== newTextContent.trim()) {
|
||
console.warn(`[SubBlockSegmenter] 警告: 块 #${parentBlockIndex} 分块前后内容不一致!`);
|
||
console.warn(`[SubBlockSegmenter] 分块前内容: "${originalTextContent.substring(0, 50)}..."`);
|
||
console.warn(`[SubBlockSegmenter] 分块后内容: "${newTextContent.substring(0, 50)}..."`);
|
||
}
|
||
|
||
// After all processing, if firstGeneratedSubBlockElement is still set (i.e., subBlockTrueCounter ended at 1)
|
||
if (firstGeneratedSubBlockElement && subBlockTrueCounter === 1) {
|
||
firstGeneratedSubBlockElement.dataset.isOnlySubBlock = "true";
|
||
// console.log(`[SubBlockSegmenter] 块 #${parentBlockIndex} 只有一个子块，标记为 isOnlySubBlock=true`);
|
||
}
|
||
|
||
// ===== 新增：记录最终生成的子块 =====
|
||
const finalSubBlocks = blockElement.querySelectorAll('.sub-block');
|
||
// console.log(`[SubBlockSegmenter] 块 #${parentBlockIndex} 最终生成 ${finalSubBlocks.length} 个子块`);
|
||
// console.log(`[SubBlockSegmenter] 子块ID列表:`, Array.from(finalSubBlocks).map(sb => sb.dataset.subBlockId));
|
||
|
||
// 分割后检测分割一致性
|
||
if (window.data && window.data.annotations) {
|
||
const allSubBlocks = Array.from(blockElement.querySelectorAll('.sub-block'));
|
||
allSubBlocks.forEach(sb => {
|
||
const subBlockId = sb.dataset.subBlockId;
|
||
const content = (sb.textContent || '').trim();
|
||
// 查找 annotation 里的 exact
|
||
const ann = window.data.annotations.find(a => a.target && a.target.selector && a.target.selector[0] && a.target.selector[0].subBlockId === subBlockId);
|
||
if (__SUBBLOCK_DEBUG__ && ann && ann.target.selector[0].exact) {
|
||
const exact = ann.target.selector[0].exact.trim();
|
||
if (content !== exact) {
|
||
console.warn(`[分割一致性检测] subBlockId=${subBlockId} 分割内容与 annotation.exact 不一致！\n分割内容: "${content}"\nannotation.exact: "${exact}"`);
|
||
}
|
||
}
|
||
//console.log(`[分割一致性] subBlockId=${subBlockId} 内容: "${content.substring(0, 40)}..."`);
|
||
});
|
||
}
|
||
|
||
// 性能埋点：分块结束
|
||
performance.mark('subBlock-end');
|
||
performance.measure('subBlockSegment', 'subBlock-start', 'subBlock-end');
|
||
}
|
||
|
||
// Expose public interface
|
||
// ===== 新增：公式检测函数 =====
|
||
function checkForFormulas(blockElement, rawText) {
|
||
// 检查LaTeX公式模式
|
||
const latexPatterns = [
|
||
/\$\$[\s\S]*?\$\$/, // 块级公式 $$...$$
|
||
/\\\[[\s\S]*?\\\]/, // 块级公式 \[...\]
|
||
/\$[^$\n]+\$/, // 行内公式 $...$
|
||
/\\\([^\n]*?\\\)/ // 行内公式 \(...\)
|
||
];
|
||
|
||
// 检查是否包含数学公式
|
||
for (const pattern of latexPatterns) {
|
||
if (pattern.test(rawText)) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
// 检查是否已经渲染的KaTeX元素
|
||
if (blockElement.querySelector('.katex, .katex-display, .katex-inline')) {
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
// ===== 新增：将整个块包装为单一子块（保留内部 DOM，不破坏 KaTeX） =====
|
||
function wrapAsSingleSubBlock(blockElement, parentBlockIndex) {
|
||
// 若已经是单一子块则跳过
|
||
const existing = blockElement.querySelectorAll(':scope > .sub-block');
|
||
if (existing.length === 1 && existing[0].dataset && existing[0].dataset.isOnlySubBlock === 'true') {
|
||
return;
|
||
}
|
||
const span = document.createElement('span');
|
||
span.className = 'sub-block';
|
||
span.dataset.subBlockId = `${parentBlockIndex}.0`;
|
||
span.dataset.isOnlySubBlock = 'true';
|
||
while (blockElement.firstChild) {
|
||
span.appendChild(blockElement.firstChild);
|
||
}
|
||
blockElement.appendChild(span);
|
||
}
|
||
|
||
// ===== 新增：公式感知的分割函数 =====
|
||
function segmentFormulaAwareBlock(blockElement, parentBlockIndex, rawText, debug) {
|
||
if (debug) {
|
||
console.log(`[SubBlockSegmenter] 开始公式感知分割，块 #${parentBlockIndex}`);
|
||
}
|
||
|
||
// ===== 新增：检测 Markdown 表格语法 =====
|
||
const hasMarkdownTableSeparator = /\|(:?-+:?\|)+/.test(rawText);
|
||
if (hasMarkdownTableSeparator) {
|
||
if (debug) {
|
||
console.log(`[SubBlockSegmenter] 块 #${parentBlockIndex} 含表格语法，包装为单一子块（原子）`);
|
||
}
|
||
wrapAsSingleSubBlock(blockElement, parentBlockIndex);
|
||
return;
|
||
}
|
||
|
||
// 检测公式位置和类型
|
||
const formulaInfo = analyzeFormulas(blockElement, rawText);
|
||
|
||
// 为了避免切断 KaTeX 或将 $$...$$ 拆分为多个子块，
|
||
// 对包含公式的块统一包装为一个原子子块。
|
||
if (formulaInfo.hasBlockFormula || formulaInfo.renderedFormulas.length > 0) {
|
||
if (debug) {
|
||
console.log(`[SubBlockSegmenter] 块 #${parentBlockIndex} 含块级/已渲染公式，包装为单一子块（原子）。`);
|
||
}
|
||
wrapAsSingleSubBlock(blockElement, parentBlockIndex);
|
||
return;
|
||
}
|
||
|
||
if (formulaInfo.hasInlineFormula) {
|
||
// 只有行内公式：使用保守分割策略，仅按句号分割且保留 DOM
|
||
return segmentWithInlineFormulaProtection(blockElement, parentBlockIndex, debug);
|
||
}
|
||
|
||
// 没有检测到公式，交由普通分割逻辑（由调用方继续执行）
|
||
return;
|
||
}
|
||
|
||
// ===== 新增：分析公式信息 =====
|
||
function analyzeFormulas(blockElement, rawText) {
|
||
const info = {
|
||
hasBlockFormula: false,
|
||
hasInlineFormula: false,
|
||
blockFormulas: [],
|
||
inlineFormulas: [],
|
||
renderedFormulas: []
|
||
};
|
||
|
||
// 检测块级公式
|
||
const blockFormulaRegex = /\$\$[\s\S]*?\$\$|\\\[[\s\S]*?\\\]/g;
|
||
let match;
|
||
while ((match = blockFormulaRegex.exec(rawText)) !== null) {
|
||
info.hasBlockFormula = true;
|
||
info.blockFormulas.push({
|
||
content: match[0],
|
||
start: match.index,
|
||
end: match.index + match[0].length
|
||
});
|
||
}
|
||
|
||
// 检测行内公式
|
||
const inlineFormulaRegex = /\$[^$\n]+\$|\\\([^\n]*?\\\)/g;
|
||
while ((match = inlineFormulaRegex.exec(rawText)) !== null) {
|
||
info.hasInlineFormula = true;
|
||
info.inlineFormulas.push({
|
||
content: match[0],
|
||
start: match.index,
|
||
end: match.index + match[0].length
|
||
});
|
||
}
|
||
|
||
// 检测已渲染的公式
|
||
const katexElements = blockElement.querySelectorAll('.katex, .katex-display, .katex-inline');
|
||
if (katexElements.length > 0) {
|
||
Array.from(katexElements).forEach(el => {
|
||
info.renderedFormulas.push({
|
||
element: el,
|
||
type: el.classList.contains('katex-display') ? 'block' : 'inline'
|
||
});
|
||
});
|
||
}
|
||
|
||
return info;
|
||
}
|
||
|
||
// ===== 新增：按公式边界分割 =====
|
||
function segmentByFormulaBreaks(blockElement, parentBlockIndex, formulaInfo, debug) {
|
||
if (debug) {
|
||
console.log(`[SubBlockSegmenter] 块 #${parentBlockIndex} 按公式边界分割，发现${formulaInfo.blockFormulas.length}个块级公式`);
|
||
}
|
||
|
||
// 获取所有分割点（句号 + 块级公式边界）
|
||
const rawText = blockElement.textContent || '';
|
||
const breakPoints = [];
|
||
|
||
// 添加句号分割点
|
||
let sentenceMatch;
|
||
const sentenceRegex = /[。]/g;
|
||
while ((sentenceMatch = sentenceRegex.exec(rawText)) !== null) {
|
||
breakPoints.push(sentenceMatch.index + 1); // +1 to include the period
|
||
}
|
||
|
||
// 添加公式边界分割点
|
||
formulaInfo.blockFormulas.forEach(formula => {
|
||
breakPoints.push(formula.start);
|
||
breakPoints.push(formula.end);
|
||
});
|
||
|
||
// 排序并去重
|
||
const uniqueBreakPoints = [...new Set(breakPoints)].sort((a, b) => a - b);
|
||
|
||
if (uniqueBreakPoints.length <= 2) {
|
||
// 分割点太少，跳过分割
|
||
return;
|
||
}
|
||
|
||
// 执行分割
|
||
return performSmartSegmentation(blockElement, parentBlockIndex, uniqueBreakPoints, rawText, debug);
|
||
}
|
||
|
||
// ===== 新增：行内公式保护分割 =====
|
||
function segmentWithInlineFormulaProtection(blockElement, parentBlockIndex, debug) {
|
||
if (debug) {
|
||
console.log(`[SubBlockSegmenter] 块 #${parentBlockIndex} 使用行内公式保护分割`);
|
||
}
|
||
|
||
// 只在句号处分割，避免切断行内公式
|
||
const rawText = blockElement.textContent || '';
|
||
const breakPoints = [0]; // 起始点
|
||
|
||
let match;
|
||
const sentenceRegex = /[。]/g;
|
||
while ((match = sentenceRegex.exec(rawText)) !== null) {
|
||
breakPoints.push(match.index + 1);
|
||
}
|
||
|
||
breakPoints.push(rawText.length); // 结束点
|
||
|
||
if (breakPoints.length <= 2) {
|
||
return; // 没有有效分割点
|
||
}
|
||
|
||
return performSmartSegmentation(blockElement, parentBlockIndex, breakPoints, rawText, debug);
|
||
}
|
||
|
||
// ===== 新增：智能分割执行 =====
|
||
function performSmartSegmentation(blockElement, parentBlockIndex, breakPoints, rawText, debug) {
|
||
let subBlockTrueCounter = 0;
|
||
const newChildNodesContainer = document.createDocumentFragment();
|
||
let firstGeneratedSubBlockElement = null;
|
||
|
||
for (let i = 0; i < breakPoints.length - 1; i++) {
|
||
const start = breakPoints[i];
|
||
const end = breakPoints[i + 1];
|
||
const segmentText = rawText.substring(start, end).trim();
|
||
|
||
if (segmentText.length === 0) continue;
|
||
|
||
// 创建子块
|
||
const span = document.createElement('span');
|
||
span.className = 'sub-block';
|
||
const subBlockId = `${parentBlockIndex}.${subBlockTrueCounter}`;
|
||
span.dataset.subBlockId = subBlockId;
|
||
span.textContent = segmentText;
|
||
|
||
if (debug) {
|
||
console.log(`[SubBlockSegmenter] 创建智能子块 #${subBlockId}, 内容: "${segmentText.substring(0, 30)}..."`);
|
||
}
|
||
|
||
newChildNodesContainer.appendChild(span);
|
||
|
||
if (subBlockTrueCounter === 0) {
|
||
firstGeneratedSubBlockElement = span;
|
||
} else {
|
||
firstGeneratedSubBlockElement = null;
|
||
}
|
||
|
||
subBlockTrueCounter++;
|
||
}
|
||
|
||
if (subBlockTrueCounter > 0) {
|
||
blockElement.innerHTML = '';
|
||
blockElement.appendChild(newChildNodesContainer);
|
||
|
||
// 标记唯一子块
|
||
if (firstGeneratedSubBlockElement && subBlockTrueCounter === 1) {
|
||
firstGeneratedSubBlockElement.dataset.isOnlySubBlock = "true";
|
||
}
|
||
|
||
if (debug) {
|
||
console.log(`[SubBlockSegmenter] 块 #${parentBlockIndex} 智能分割完成，生成 ${subBlockTrueCounter} 个子块`);
|
||
}
|
||
}
|
||
}
|
||
|
||
global.SubBlockSegmenter = {
|
||
segment: segmentBlockIntoSubBlocks,
|
||
// 暴露新功能用于测试
|
||
checkForFormulas: checkForFormulas,
|
||
analyzeFormulas: analyzeFormulas
|
||
};
|
||
|
||
})(window);
|