How to find and replace line breaks in Word document as paragraph marks?

using Syncfusion.DocIO;
using Syncfusion.DocIO.DLS;

using (FileStream fileStreamPath = new FileStream(Path.GetFullPath(@"../../../Data/Input.docx"), FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
{
    // Open an existing Word document.
    using (WordDocument document = new WordDocument(fileStreamPath, FormatType.Docx))
    {
        // Replace line breaks with paragraph marks in the Word document.
        ReplaceLineBreakWithPara(document);
        // Create a file stream.
        using (FileStream outputFileStream = new FileStream(Path.GetFullPath("../../../Sample.docx"), FileMode.Create, FileAccess.ReadWrite))
        {
            // Save the Word document to the file stream.
            document.Save(outputFileStream, FormatType.Docx);
        }
    }
}

/// <summary>
/// Replace the line breaks with paragraph marks in the Word document.
/// </summary>
private static void ReplaceLineBreakWithPara(WordDocument document)
{
    foreach (WSection section in document.Sections)
    {
        // Access the body section of the Word document.
        WTextBody sectionBody = section.Body;
        IterateTextBody(sectionBody);
        WHeadersFooters headersFooters = section.HeadersFooters;
        // Iterate through the TextBody of OddHeader and OddFooter.
        IterateTextBody(headersFooters.OddHeader);
        IterateTextBody(headersFooters.OddFooter);
    }
}
/// <summary>
/// Iterate text body child elements.
/// </summary>
private static void IterateTextBody(WTextBody textBody)
{
    // Iterate the child items of the text body.
    for (int i = 0; i < textBody.ChildEntities.Count; i++)
    { 
        // Check the text body items.
        IEntity bodyItemEntity = textBody.ChildEntities[i];
        // Check the entity type.
        switch (bodyItemEntity.EntityType)
        {
            case EntityType.Paragraph:
                WParagraph paragraph = bodyItemEntity as WParagraph;
                // Iterate through the paragraph.
                IterateParagraphItems(paragraph.Items);
                break;
            case EntityType.Table:
                // Iterate through the table.
                IterateTable(bodyItemEntity as WTable);
                break;
            case EntityType.BlockContentControl:
                BlockContentControl blockContentControl = bodyItemEntity as BlockContentControl;
                // Iterate the body items of the Block Content Control.
                IterateTextBody(blockContentControl.TextBody);
                break;
        }
    }
}
/// <summary>
/// Iterate table child elements.
/// </summary>
private static void IterateTable(WTable table)
{
    // Iterate the row collection in a table.
    foreach (WTableRow row in table.Rows)
    {
        // Iterate the cell collection in a table row.
        foreach (WTableCell cell in row.Cells)
        {
            IterateTextBody(cell);
        }
    }
}
/// <summary>
/// Iterate paragraph child elements.
/// </summary>
private static void IterateParagraphItems(ParagraphItemCollection paraItems)
{
    for (int i = 0; i < paraItems.Count; i++)
    {
        Entity entity = paraItems[i];
        // Check the element type by using EntityType.
        switch (entity.EntityType)
        {
            case EntityType.Break:
                Break breakItem = entity as Break;
                // Replace line break with paragraph mark.
                if (breakItem.BreakType == BreakType.LineBreak)
                {
                    WParagraph ownerPara = breakItem.OwnerParagraph;
                    int breakIndex = ownerPara.ChildEntities.IndexOf(breakItem);
                    int paraIndex = ownerPara.OwnerTextBody.ChildEntities.IndexOf(ownerPara);
 
                    // Create a new paragraph by cloning the existing paragraph.
                    WParagraph newPara = ownerPara.Clone() as WParagraph;                           
                    // Remove paragraph child entities from the index of break item.
                    while (breakIndex <ownerPara.ChildEntities.Count)                           
                    ownerPara.ChildEntities.RemoveAt(breakIndex);
                    // Remove paragraph child entities from index zero up to the index of the break in the cloned paragraph.
                    for (int j = 0; j < breakIndex + 1; j++)
                    newPara.ChildEntities.RemoveAt(0);
                    // Insert the new paragraph next to the line break paragraph.
                    ownerPara.OwnerTextBody.ChildEntities.Insert(paraIndex + 1, newPara);
                }
                break;
            case EntityType.TextBox:
                // Iterate the body items of the textbox.
                WTextBox textBox = entity as WTextBox;
                IterateTextBody(textBox.TextBoxBody);
                break;
            case EntityType.Shape:
                // Iterate the body items of the shape.
                Shape shape = entity as Shape;
                IterateTextBody(shape.TextBody);
                break;
            case EntityType.InlineContentControl:
                // Iterate the paragraph items of the inline content control.
                InlineContentControl inlineContentControl = entity as InlineContentControl;
                IterateParagraphItems(inlineContentControl.ParagraphItems);
                break;
        }
    }
}