基类 TextSplitter（libs/text-splitters/langchain_text_splitters/base.py:59）的构造函数把规矩立在最前面：

# libs/text-splitters/langchain_text_splitters/base.py:59
class TextSplitter(BaseDocumentTransformer, ABC):
    """Interface for splitting text into chunks."""

    def __init__(
        self,
        chunk_size: int = 4000,          # ① 每册最多多少"长度单位"
        chunk_overlap: int = 200,        # ② 册间重印多少
        length_function: Callable[[str], int] = len,   # ③ ★"长度"怎么量：默认数字符
        keep_separator: bool | Literal["start", "end"] = False,
        add_start_index: bool = False,   # 是否在 metadata 里记录块的起点
        strip_whitespace: bool = True,
    ) -> None:
        if chunk_size <= 0:
            raise ValueError(msg)                       # 约法一：册厚必须为正
        if chunk_overlap < 0:
            raise ValueError(msg)                       # 约法二：重叠不能为负
        if chunk_overlap > chunk_size:
            msg = (f"Got a larger chunk overlap ({chunk_overlap}) than chunk size "
                   f"({chunk_size}), should be smaller.")
            raise ValueError(msg)                       # 约法三：重叠必须小于册厚
        self._chunk_size = chunk_size
        self._chunk_overlap = chunk_overlap
        self._length_function = length_function
        ...

    @abstractmethod
    def split_text(self, text: str) -> list[str]: ...   # base.py:108 子类唯一必须实现的

子类先把文本按分隔符剁成小片（splits），然后统一交给基类的 _merge_splits（libs/text-splitters/langchain_text_splitters/base.py:167）装箱成册——这是全包最核心的 40 行：

# libs/text-splitters/langchain_text_splitters/base.py:167
def _merge_splits(self, splits: Iterable[str], separator: str) -> list[str]:
    separator_len = self._length_function(separator)
    docs = []
    current_doc: list[str] = []          # 当前正在装的这一册
    total = 0                            # 当前册的累计厚度
    for d in splits:
        len_ = self._length_function(d)
        if (total + len_ + (separator_len if len(current_doc) > 0 else 0)
                > self._chunk_size):     # ① 再装这片就超厚了？
            if total > self._chunk_size:
                logger.warning("Created a chunk of size %d, which is longer "
                               "than the specified %d", total, self._chunk_size)
            if len(current_doc) > 0:
                doc = self._join_docs(current_doc, separator)   # ② 当前册装订出货
                if doc is not None:
                    docs.append(doc)
                while total > self._chunk_overlap or (          # ③ ★从册头弹出旧片，
                    total + len_ + ... > self._chunk_size and total > 0   #   只留 overlap 的量
                ):
                    total -= self._length_function(current_doc[0]) + ...
                    current_doc = current_doc[1:]               #   ← 弹出最旧的一片
        current_doc.append(d)            # ④ 新片入册
        total += len_ + (separator_len if len(current_doc) > 1 else 0)
    doc = self._join_docs(current_doc, separator)               # ⑤ 收尾：最后一册出货
    if doc is not None:
        docs.append(doc)
    return docs

最简单的子类 CharacterTextSplitter（libs/text-splitters/langchain_text_splitters/character.py:13）——只认一个分隔符：

# libs/text-splitters/langchain_text_splitters/character.py:13
class CharacterTextSplitter(TextSplitter):
    """Splitting text that looks at characters."""

    def __init__(self, separator: str = "\n\n", is_separator_regex: bool = False, **kwargs):
        super().__init__(**kwargs)
        self._separator = separator          # 默认按"空行"（段落边界）下刀

    @override
    def split_text(self, text: str) -> list[str]:    # character.py:28
        sep_pattern = (self._separator if self._is_separator_regex
                       else re.escape(self._separator))
        splits = _split_text_with_regex(text, sep_pattern,          # ① 按分隔符剁成片
                                        keep_separator=self._keep_separator)
        ...
        merge_sep = ""
        if not (self._keep_separator or is_lookaround):
            merge_sep = self._separator
        return self._merge_splits(splits, merge_sep)                 # ② 交给基类装箱

官方默认切分器（D09 的 load_and_split 就用它）：RecursiveCharacterTextSplitter（libs/text-splitters/langchain_text_splitters/character.py:91）：

# libs/text-splitters/langchain_text_splitters/character.py:91
class RecursiveCharacterTextSplitter(TextSplitter):
    """Splitting text by recursively look at characters.
    Recursively tries to split by different characters to find one that works."""

    def __init__(self, separators=None, keep_separator=True, ...):
        super().__init__(keep_separator=keep_separator, **kwargs)
        self._separators = separators or ["\n\n", "\n", " ", ""]   # ★刀谱：段→行→词→字

    def _split_text(self, text: str, separators: list[str]) -> list[str]:  # character.py:110
        final_chunks = []
        separator = separators[-1]
        new_separators = []
        for i, s_ in enumerate(separators):
            if re.search(separator_, text):        # ① 选出当前文本里能用的最粗的刀
                separator = s_
                new_separators = separators[i + 1 :]   #    剩下的细刀留给递归
                break
        splits = _split_text_with_regex(text, separator_, ...)   # ② 用选中的刀剁片
        good_splits = []
        for s in splits:
            if self._length_function(s) < self._chunk_size:
                good_splits.append(s)              # ③ 片够小 → 攒着待装箱
            else:
                if good_splits:
                    final_chunks.extend(self._merge_splits(good_splits, separator_))
                    good_splits = []
                if not new_separators:
                    final_chunks.append(s)         # ④ 刀用完了，认了
                else:
                    final_chunks.extend(self._split_text(s, new_separators))  # ⑤ ★换细刀递归
        if good_splits:
            final_chunks.extend(self._merge_splits(good_splits, separator_))
        return final_chunks

切分器怎么和 D09 的 Document 世界接轨？看 create_documents（libs/text-splitters/langchain_text_splitters/base.py:118）和 split_documents（base.py:146）：

# libs/text-splitters/langchain_text_splitters/base.py:118
def create_documents(self, texts, metadatas=None) -> list[Document]:
    metadatas_ = metadatas or [{}] * len(texts)
    documents = []
    for i, text in enumerate(texts):
        index = 0
        previous_chunk_len = 0
        for chunk in self.split_text(text):
            metadata = copy.deepcopy(metadatas_[i])       # ① ★母卡片深拷贝给每个子块
            if self._add_start_index:
                offset = index + previous_chunk_len - self._chunk_overlap
                index = text.find(chunk, max(0, offset))  # ② 定位块在原文的起点
                metadata["start_index"] = index
                previous_chunk_len = len(chunk)
            documents.append(Document(page_content=chunk, metadata=metadata))
    return documents

# base.py:146
def split_documents(self, documents: Iterable[Document]) -> list[Document]:
    texts, metadatas = [], []
    for doc in documents:
        texts.append(doc.page_content)
        metadatas.append(doc.metadata)                    # ③ 拆出正文和卡片
    return self.create_documents(texts, metadatas=metadatas)