LangChain Text Splitters vs LlamaIndex Node Parsers: Which Chunking Tool Wins for RAG

LangChain Text Splitters vs LlamaIndex Node Parsers: Which Chunking Tool Wins for RAG

When you build a system that can answer questions using your own documents, it’s called Retrieval Augmented Generation, or RAG. For your RAG system to work well, it needs to find the right pieces of information very quickly. This is where “chunking” or “text splitting” becomes super important.

You might have heard of tools like LangChain and LlamaIndex, which are popular RAG frameworks. Both help you prepare your documents, but they do it in slightly different ways. Today, we’re going to dive into the core of how they break down text: LangChain text splitters vs LlamaIndex node parsers. We’ll see which chunking comparison tool might be better for your document processing needs.

Understanding Chunking for RAG

Imagine you have a giant textbook and you want to find a specific answer. It would be impossible to read the whole book every time you have a question. Instead, you’d flip to the right chapter or section. This is exactly what chunking does for your AI system.

Large language models (LLMs) can only read a certain amount of text at one time. If your documents are too long, the LLM won’t be able to process them all. Chunking breaks these long documents into smaller, manageable pieces, making it easier for the AI to find and understand relevant information. A good chunk should be small enough to fit into the LLM’s memory but large enough to contain a complete thought or idea.

Proper document processing and chunking are the backbone of an efficient RAG system. It directly impacts how accurately and quickly your AI can retrieve answers. Without effective chunking, your AI might miss important details or get confused by too much irrelevant information.

LangChain Text Splitters: The Basics

LangChain provides many different tools to split your text, which they call “text splitters.” These splitters are very flexible and can be adapted to many kinds of documents. They focus on dividing a big piece of text into smaller, independent Document objects.

LangChain’s approach is often rules-based, meaning you tell it how to split, for example, by character count or by common separators like new lines. You can easily control the size of your chunks and how much they overlap. This makes them a great starting point for many RAG frameworks.

When you use a LangChain text splitter, you typically get a list of smaller Document objects back. Each Document contains a piece of your original text and can also hold some metadata. This metadata can include things like the source of the text or page numbers, which can be useful later on.

Common LangChain Text Splitters

LangChain offers a variety of text splitters, each designed for different splitting strategies. You can choose the one that best fits the structure of your documents and your specific needs. Understanding these options is key to effective document processing.

CharacterTextSplitter

This is one of the simplest text splitters. It breaks your text into chunks based on a fixed number of characters. You can tell it how many characters each chunk should have and how much overlap there should be between chunks.

For example, you could tell it to make chunks of 1000 characters with a 200-character overlap. It’s straightforward but might cut sentences in half. It’s a good choice for very unstructured text where you just need basic pieces.

RecursiveCharacterTextSplitter

This splitter is smarter because it tries different ways to split your text. It starts with common separators like new lines, then moves to spaces, and finally to characters if needed. This helps keep sentences and paragraphs together more often.

It’s often considered the go-to splitter for general-purpose document processing in LangChain. By trying multiple separators, it aims to create more meaningful chunks. You can specify a list of separators, and it will try them in order until a chunk is small enough.

SemanticTextSplitter

The SemanticTextSplitter is a more advanced tool that tries to split text based on its meaning, not just characters or tokens. It uses an embedding model to understand the semantic similarity between sentences. This means it tries to keep chunks together that are conceptually related.

If you want chunks that truly represent a single idea or topic, a Semantic Text Splitter can be very powerful. It’s a great example of how you can use more intelligent methods for better chunking. You can learn more about this in our post on [Semantic Text Splitter](/langchain-semantic-text-splitter-chunk-by-meaning/).

TokenTextSplitter

Instead of counting characters, this splitter counts “tokens.” Tokens are the pieces that large language models (LLMs) break words into. For example, “running” might be one token, but “ran” and “ning” could be two. Splitting by tokens helps ensure your chunks fit within the LLM’s context window perfectly.

Each LLM has its own tokenizer, so this splitter uses one that matches your chosen model. This is very important to avoid exceeding the model’s input limit. It directly addresses the technical constraints of the LLM you are using for RAG frameworks.

How to Use LangChain Text Splitters

Using a LangChain text splitter is usually very simple. You import the splitter, give it your long text, and it returns a list of smaller documents. You often set chunk_size and chunk_overlap.

Let’s look at a quick example using the RecursiveCharacterTextSplitter. This snippet shows you how to initialize the splitter and use it on some sample text. This is a common pattern you’ll see across many LangChain components for document processing.

from langchain.text_splitter import RecursiveCharacterTextSplitter

# Imagine this is your very long document
long_text = """
Chapter 1: The Beginning. This is the first paragraph of our story. It talks about a small village and its unique customs. The villagers were known for their kindness and their delicious bread. They lived peaceful lives, unaware of the adventures that awaited them just beyond the forest.

Chapter 2: The Forest's Edge. Our hero, Elara, ventured into the Whispering Woods. The trees were ancient, their branches intertwined like gnarled fingers. Strange sounds echoed through the canopy, making her heart pound. She clutched her satchel tighter, a brave but nervous girl.

Chapter 3: An Unexpected Meeting. Deep within the woods, Elara stumbled upon a hidden glade. A wise old owl sat perched on a mossy rock, its eyes glinting with ancient knowledge. The owl spoke, not in hoots, but in a language only Elara could understand, revealing a prophecy.
"""

# Initialize the splitter
# We want chunks of about 300 characters with 50 characters of overlap
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=300,
    chunk_overlap=50,
    length_function=len,
    is_separator_regex=False,
)

# Split the text
chunks = text_splitter.create_documents([long_text])

# Print out the chunks and their metadata
print(f"Number of chunks: {len(chunks)}")
for i, chunk in enumerate(chunks):
    print(f"\n--- Chunk {i+1} ---")
    print(chunk.page_content)
    print(f"Metadata: {chunk.metadata}")

In this example, the RecursiveCharacterTextSplitter will try to split the text intelligently based on new lines first, then spaces. This helps to keep the sentences intact. The chunk_overlap ensures that some context from the end of one chunk is carried over to the beginning of the next, which is important for understanding.

LlamaIndex Node Parsers: An Overview

LlamaIndex takes a slightly different approach to document processing for RAG. While LangChain focuses on splitting text into a list of generic documents, LlamaIndex is all about creating “Nodes” that can hold rich metadata and define relationships with each other. This is crucial for building more sophisticated RAG frameworks.

Think of LlamaIndex not just as splitting text, but as parsing your documents into a knowledge graph. Each “Node” represents a meaningful piece of information, like a paragraph, a sentence, or even a table. These nodes can then be connected to other nodes, forming a web of information.

The LlamaIndex node parsers are the tools that perform this transformation. They don’t just return raw text chunks; they return Node objects. These Node objects are richer, carrying not only the text content but also important metadata like its parent document, its relationship to other nodes, and other specific properties. This structured output is a core strength of LlamaIndex.

Types of LlamaIndex Node Parsers

LlamaIndex offers specialized node parsers designed to handle various document structures and RAG strategies. These parsers aim to create nodes that are not just chunks of text but intelligent data units with context. This advanced document processing is what sets LlamaIndex apart.

SimpleNodeParser

This is the most basic node parser in LlamaIndex. It works similarly to some LangChain text splitters by breaking down a document into a flat list of nodes. It usually splits by sentences or paragraphs. It’s a good starting point if you need simple chunks but still want the LlamaIndex Node structure.

The SimpleNodeParser will take your raw text and turn each paragraph or sentence into its own Node. Each node will automatically include metadata about its parent document. This gives you a foundation for building more complex RAG systems with LlamaIndex.

SentenceWindowNodeParser

This is a very clever parser for RAG frameworks. It creates smaller “sentence window” nodes that are perfect for retrieval. Each retrieved node is typically a single sentence, which is great for precision. However, it then fetches a larger “window” of surrounding sentences to give the LLM more context for generation.

The idea is that a single sentence is great for matching during retrieval, but not enough for the LLM to generate a good answer. The “window” provides the necessary context without making the initial chunks too large. This significantly improves the quality of answers by giving the LLM more surrounding information.

HierarchicalNodeParser

The HierarchicalNodeParser is designed for documents with clear structures, like books, reports, or articles with headings. It creates nodes at different levels of granularity. For example, it can create a node for an entire chapter, then smaller nodes for sections within that chapter, and even smaller nodes for paragraphs within those sections.

This parser helps LlamaIndex build a hierarchical understanding of your document. When you query, LlamaIndex can retrieve information from the most relevant level, whether it’s a broad overview or a specific detail. This is incredibly powerful for navigating complex documents during document processing.

JSONNodeParser

As the name suggests, the JSONNodeParser is specifically built to parse JSON documents. JSON is a structured data format often used for APIs and configuration files. This parser can extract key-value pairs, lists, and nested objects from your JSON, turning them into LlamaIndex nodes.

This is extremely useful when your knowledge base isn’t just free-form text but also contains structured data. The JSONNodeParser helps you incorporate that structured information directly into your RAG system, allowing you to query specific fields or objects within your JSON. It’s a specialized tool for specific document processing tasks.

How to Use LlamaIndex Node Parsers

Using LlamaIndex node parsers involves loading your data and then passing it through the parser. The output will be a list of Node objects, each with its content and associated metadata. LlamaIndex often handles the data loading as well.

Here’s an example using the SimpleNodeParser. Notice how LlamaIndex documents (Document) are distinct from LangChain documents, and they often contain richer metadata. This structure is fundamental to how LlamaIndex operates within RAG frameworks.

from llama_index.core.schema import Document
from llama_index.core.node_parser import SimpleNodeParser

# Create a LlamaIndex Document object
# This can come from loading a file (e.g., PDF, text file)
document = Document(
    text="""
    Section A: Introduction to Widgets. Widgets are small, interactive elements.
    They improve user experience by providing quick access to features.
    Widgets can be customized to fit various themes and functionalities.

    Section B: Advanced Widget Features. Modern widgets often include AI capabilities.
    These can range from predictive text to smart recommendations.
    Integrating widgets requires careful planning and testing.
    """,
    metadata={"file_name": "widgets_guide.txt", "author": "AI Guide"},
)

# Initialize the SimpleNodeParser
# You can specify chunk size, but it often defaults to sentence/paragraph splitting
node_parser = SimpleNodeParser.from_defaults(
    chunk_size=100,  # Example: splits into chunks of approx 100 tokens/characters
    chunk_overlap=20,
)

# Get nodes from documents
nodes = node_parser.get_nodes_from_documents([document])

# Print out the nodes
print(f"Number of nodes: {len(nodes)}")
for i, node in enumerate(nodes):
    print(f"\n--- Node {i+1} ---")
    print(f"Node ID: {node.id_}")
    print(f"Text: {node.text}")
    print(f"Metadata: {node.metadata}")
    print(f"Relationships: {node.relationships}") # Shows parent, next, previous nodes

You can see that LlamaIndex nodes have more properties like id_ and relationships. These are key for building sophisticated retrieval strategies beyond simple keyword matching. The relationships field is particularly powerful for creating a graph-like structure from your documents during document processing.

Key Differences: LangChain Text Splitters vs LlamaIndex Node Parsers

Now that we’ve looked at both, let’s highlight the main distinctions between LangChain text splitters vs LlamaIndex node parsers. This chunking comparison will help you understand their unique strengths. They both aim to break down text for RAG, but their underlying philosophies and output structures differ significantly.

Philosophy

LangChain Text Splitters: Their philosophy is about providing flexible, modular tools for various document processing tasks. They are often seen as utility functions that take raw text and return processed text chunks (as Document objects). The focus is on the splitting logic itself, giving you control over how text is divided.

LlamaIndex Node Parsers: Their philosophy is more about creating a structured, knowledge-graph-like representation of your data. They don’t just split text; they parse it into rich Node objects that can hold complex metadata and define relationships. The goal is to build an intelligent index that understands the context and connections within your information. LlamaIndex really shines when you need to reason over interconnected pieces of information.

Output

LangChain Text Splitters: The output is typically a list of Document objects. Each Document usually has two main parts: page_content (the text chunk) and metadata (a dictionary of additional information). While metadata can be attached, it’s not inherently part of the splitting process itself.

LlamaIndex Node Parsers: The output is a list of Node objects. Each Node is much richer than a simple Document object. It includes the text content, a unique ID, rich metadata (like source, page number, section, etc.), and most importantly, relationships to other nodes (e.g., parent, child, next, previous). This hierarchical and relational information is a core feature for advanced document processing.

Complexity

LangChain Text Splitters: Generally easier to get started with for basic chunking needs. If you just need to break a long PDF or text file into fixed-size segments, LangChain’s splitters are very straightforward. They offer a good balance of simplicity and functionality for many common RAG frameworks.

LlamaIndex Node Parsers: Can be more complex to initially grasp due to the concept of Nodes and their relationships. However, this complexity pays off when dealing with structured documents or when you need a RAG system that understands deeper connections within your data. It provides more powerful tools for advanced document processing tasks.

Metadata Handling

LangChain Text Splitters: Metadata can be passed along with the original document and will be propagated to the chunks. You can also add custom metadata. However, the splitter itself doesn’t typically infer new, complex relationships or hierarchical metadata during the splitting process.

LlamaIndex Node Parsers: Metadata is a central part of the Node structure. Parsers like HierarchicalNodeParser actively generate and attach meaningful metadata (e.g., parent section, source document) as they parse the document. This is critical for building a robust LlamaIndex knowledge base and enabling more precise retrieval.

Use Cases

LangChain Text Splitters: Ideal for general-purpose text splitting. If you have unstructured text (like a collection of blog posts, emails, or chat logs) and you need to break it into chunks for basic Q&A, LangChain’s splitters are an excellent choice. They are versatile and integrate well into various RAG frameworks. They are especially good when you need to quickly build RAG applications without too much overhead.

LlamaIndex Node Parsers: Shines when dealing with structured documents (like textbooks, technical manuals, financial reports, or JSON data) where preserving context, hierarchy, and relationships is key. If your RAG system needs to perform complex reasoning, answer questions that span multiple sections, or understand the structure of your data, LlamaIndex’s node parsers offer superior capabilities for document processing.

Comparison Table

Here’s a quick chunking comparison between LangChain text splitters vs LlamaIndex node parsers. This table summarizes their core features and helps you see the differences at a glance, aiding your decision for RAG frameworks.

Feature	LangChain Text Splitters	LlamaIndex Node Parsers
Core Idea	Breaking raw text into smaller, manageable chunks.	Parsing documents into rich, interconnected Node objects.
Primary Output	List of Document objects (text + simple metadata).	List of Node objects (text + rich metadata + relationships).
Metadata Handling	Propagates existing metadata; basic additions.	Actively generates and embeds hierarchical/relational metadata.
Structural Awareness	Limited; primarily text-based rules.	High; understands document hierarchy, sections, etc.
Complexity	Generally simpler to use for straightforward splitting.	Can be more complex but offers greater capabilities.
Best For	Unstructured text, basic Q&A, rapid prototyping in RAG frameworks.	Structured documents, complex reasoning, knowledge graph building.
RAG Strategy Focus	Efficient retrieval of text segments.	Intelligent retrieval based on context, relationships, and structure.
Integration	Part of the broader LangChain ecosystem for building agents and chains.	Core to LlamaIndex’s indexing and query engine capabilities.

Practical Examples: When to Choose Which

Deciding between LangChain text splitters vs LlamaIndex node parsers often comes down to the specifics of your project. Let’s look at some real-world scenarios to help you make an informed choice for your document processing needs. This chunking comparison will show you where each tool truly excels within RAG frameworks.

Example 1: Simple Blog Post (LangChain Wins)

Scenario: You have a collection of blog posts, articles, or simple internal memos. You want to build a basic RAG system that can answer general questions about their content. The documents are mostly free-flowing text without complex structures like tables or deeply nested sections.

Why LangChain: For this kind of unstructured text, a RecursiveCharacterTextSplitter from LangChain is usually perfect. It’s easy to set up, highly effective at splitting text while trying to maintain sentence integrity, and produces clean chunks. You don’t need the overhead of complex Node relationships when the structure isn’t there to begin with. It’s a quick and efficient way to prepare your data for build RAG applications.

Code Snippet Idea:

from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.schema import Document

blog_post = """
Our company just launched a new initiative focused on sustainability. We aim to reduce our carbon footprint by 30% over the next two years. This will involve updating our manufacturing processes, sourcing materials more locally, and encouraging remote work. Employees are invited to a town hall next month to discuss these changes and provide feedback. We believe this initiative will not only benefit the environment but also improve our brand image and attract new talent.
"""

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=100,
    separators=["\n\n", "\n", " ", ""],
    length_function=len
)

# Use create_documents for easy Document object creation
chunks = text_splitter.create_documents([blog_post])

print(f"LangChain split blog post into {len(chunks)} chunks.")
for i, chunk in enumerate(chunks):
    print(f"\n--- LangChain Chunk {i+1} ---")
    print(chunk.page_content)
    # Metadata is simple here, usually just source or basic info
    print(f"Metadata: {chunk.metadata}")

Example 2: Technical Documentation with Sections (LlamaIndex Shines)

Scenario: You’re building a RAG system over a large technical manual or a software development guide. This document has clear sections, subsections, code blocks, and maybe even a table of contents. You need your RAG system to understand that “Section 3.1” is part of “Chapter 3” and answer questions that require context from both the specific detail and the broader section.

Why LlamaIndex: This is where LlamaIndex node parsers become incredibly powerful. The HierarchicalNodeParser can parse the document structure, creating nodes for chapters, sections, and paragraphs, and linking them together. If you also want very precise retrieval, the SentenceWindowNodeParser can be used to generate small, precise sentence nodes for initial search, then expand to a larger context window for the LLM. This level of document processing is difficult to achieve with simple text splitters.

Code Snippet Idea:

from llama_index.core.schema import Document
from llama_index.core.node_parser import HierarchicalNodeParser
from llama_index.core.extractors import TitleExtractor, SummaryExtractor
from llama_index.core.llms import OpenAI

# Sample complex document text
tech_doc = """
# Chapter 1: Getting Started with API v2.0

## 1.1 Installation
To install the new API client, run:
```bash
pip install my-api-client==2.0

Ensure you have Python 3.9 or higher.

1.2 Authentication

Authentication now uses OAuth2.0. Generate your client ID and secret from the developer console. Example Python code for authentication:

from my_api_client import Client
client = Client(client_id="YOUR_ID", client_secret="YOUR_SECRET")
token = client.authenticate()

Chapter 2: Using Endpoints

2.1 User Management

Endpoints for user management include /users (GET, POST) and /users/{id} (GET, PUT, DELETE). “””

Create a LlamaIndex Document

document = Document( text=tech_doc, metadata={“source”: “API_Guide_v2.0.pdf”} )

Initialize the HierarchicalNodeParser

It often works best with other LlamaIndex extractors for richer nodes

parser = HierarchicalNodeParser.from_defaults( chunk_sizes=[2048, 512, 128], # Chunks for document, section, paragraph # Optionally, integrate extractors for titles or summaries # This example keeps it simple, but you could add # node_parser.transform([document], extractors=[TitleExtractor()]) )

nodes = parser.get_nodes_from_documents([document])

print(f”LlamaIndex parsed technical document into {len(nodes)} nodes (potentially hierarchical).”)

You would typically build an index here to see the hierarchy

for i, node in enumerate(nodes[:5]): # Print first few nodes for brevity print(f”\n— LlamaIndex Node {i+1} —”) print(f”Node ID: {node.id_}”) print(f”Text: {node.text[:100]}…”) # Show first 100 chars print(f”Metadata: {node.metadata}”) print(f”Relationships: {node.relationships}”) # See parent, child, etc. ```

Example 3: Processing Financial Reports (LlamaIndex is Great)

Scenario: Your RAG system needs to analyze quarterly financial reports that contain structured data in tables, specific figures embedded in text, and distinct sections like “Income Statement,” “Balance Sheet,” and “Notes to Accounts.” You might want to ask questions like “What was the net income in Q3, 2025, according to the Income Statement?”

Why LlamaIndex: LlamaIndex’s ability to create rich nodes with metadata is invaluable here. You can parse tables into specific nodes, attach metadata like “section: Income Statement” to relevant text, and even use specialized parsers for structured formats if the reports are available in JSON or XML. This ensures that when the RAG system retrieves information, it knows exactly where that information came from within the report’s structure. This advanced document processing maintains crucial context.

Example 4: Building a Sophisticated Multi-step Agent (Both, but LlamaIndex for structure)

Scenario: You’re building a complex AI agent that needs to perform multi-step tasks, like researching a topic across several internal documents, summarizing findings, and then generating a plan. This multi-step AI agent needs to understand not just snippets of text but also how different pieces of information relate to each other across various sources.

Why Both, but LlamaIndex for structure: You might start with LangChain text splitters for initial document processing of simpler, unstructured parts of your data. However, for the agent to deeply “understand” and reason across complex documents or a collection of documents with internal references, LlamaIndex’s node parsers and the resulting knowledge graph become essential. The structured nodes and their relationships allow the agent to traverse information intelligently, rather than just retrieving isolated chunks. For details on building such agents, you might look at [multi-step AI agent](/langgraph-stategraph-multi-step-ai-agent/).

Tips for Choosing the Right Chunking Tool

Choosing between LangChain text splitters vs LlamaIndex node parsers is a critical decision for your RAG project. There’s no single “best” tool; the right choice depends on your specific needs. Here are some tips to guide your chunking comparison and document processing strategy.

Understand Your Data

Before you even think about splitting, take a good look at your source documents. Are they mostly free-flowing text like articles and chat logs, or do they have a clear, organized structure like textbooks, technical manuals, or financial reports? Documents with headings, sections, tables, and hierarchical information often benefit more from LlamaIndex’s approach. Simpler, unstructured text can be handled very effectively by LangChain.

Consider Your RAG Complexity

What kind of questions do you expect your RAG system to answer? If you only need straightforward answers from individual snippets of text, LangChain’s simpler text splitters are probably sufficient. If you need your RAG system to perform complex reasoning, synthesize information from multiple related sections, or understand deep contextual relationships, LlamaIndex’s node parsers will provide the necessary foundation. More advanced RAG frameworks often benefit from the structured approach of LlamaIndex.

Metadata Needs

How important is it to preserve or generate rich metadata during document processing? If simply knowing the source document is enough, LangChain works fine. However, if you need to know the chapter, section, page number, author, or even the type of content (e.g., “code snippet,” “table data”) for each chunk, LlamaIndex offers superior capabilities for managing and leveraging this metadata through its Node objects.

Experiment

The best way to know which tool is right for you is to try them out! Take a sample of your actual data and experiment with both LangChain text splitters and LlamaIndex node parsers. Compare the quality of the chunks (or nodes) they produce and how well your RAG system performs with each. You might even find that a combination of both tools, using each for its strengths, yields the best results for your unique RAG frameworks.

Future Trends in Chunking

The field of document processing and chunking for RAG is constantly evolving. As LLMs become more sophisticated and RAG frameworks mature, we can expect even smarter ways to break down information. The chunking comparison we’ve done today is just a snapshot of current best practices.

One exciting trend is AI-driven chunking. Instead of relying solely on rules (like character count or separators), future chunking tools might use AI to understand the document’s content and automatically identify meaningful segments. This could lead to highly semantic chunks that perfectly capture a single idea. Another trend is more context-aware splitting, where chunking strategies dynamically adapt based on the specific query or the user’s intent, ensuring the most relevant context is always retrieved.

Finally, as RAG frameworks expand into multimodal data (images, audio, video), we will see the integration of multimodal chunking. This means not just splitting text, but also breaking down and interlinking information across different types of media, creating an even richer knowledge base for AI. These advancements will continue to push the boundaries of what’s possible with LlamaIndex and LangChain.

Conclusion

In the battle of LangChain text splitters vs LlamaIndex node parsers, there isn’t a single winner. Both are powerful tools for document processing within RAG frameworks, but they cater to different needs and document complexities. LangChain’s text splitters offer flexibility and ease of use for general-purpose chunking of unstructured text. They are excellent for quickly setting up basic RAG systems and for documents where deep structural understanding isn’t a primary requirement.

LlamaIndex node parsers, on the other hand, provide a more sophisticated approach, transforming documents into rich, interconnected Node objects. This is invaluable when dealing with structured documents, requiring hierarchical understanding, or building advanced RAG systems that need to reason over complex relationships and rich metadata. Its focus on creating a knowledge graph makes it a strong contender for more intricate document processing tasks.

Ultimately, your choice depends on the nature of your data, the complexity of your RAG application, and your specific requirements for metadata and structural understanding. Experiment with both, understand their strengths, and choose the chunking comparison tool that best empowers your RAG system to retrieve and generate accurate, context-rich answers.