QuestPDF: SetHTML Ignores Spaces In Nested Tags

Dec 3, 2025 by Admin 48 views

Hey guys! Today, we're diving into a quirky issue with QuestPDF where spaces inside nested HTML tags are being ignored when you're rendering HTML using handler.SetHtml(). Specifically, we're talking about non-breaking spaces ( ) and how they mysteriously vanish in the final PDF output. Let's break down the problem, explore the code, and figure out how to make those spaces stick around.

The Problem: Vanishing Spaces

So, you've got some HTML that looks perfectly fine in a browser, but when QuestPDF processes it, those crucial spaces just disappear. This is especially noticeable when you're using non-breaking spaces to ensure certain elements stay visually separated. Imagine you have this HTML snippet:

<span>This is a<span>&nbsp;</span></span><strong>bold</strong><span><span>&nbsp;</span>text</span>

You'd expect to see "This is a bold text" with spaces around the word "bold". But instead, you might end up with "This is aboldtext", which isn't quite what you wanted.

This issue can be a real headache when you're trying to maintain precise formatting in your documents. Whether it's aligning text, creating visual separation, or just ensuring readability, those spaces are essential. And when they disappear, it can throw off the entire layout and make your PDF look unprofessional.

Why Spaces Matter?

Spaces are more than just blank characters; they're crucial for visual clarity and readability. In document design, the right amount of whitespace can significantly improve the user experience. It helps to:

Separate elements: Spaces prevent text and other elements from crowding each other, making it easier to distinguish between different parts of the content.
Improve readability: Adequate spacing between words and lines allows the reader's eye to move smoothly across the page, reducing strain and improving comprehension.
Create visual hierarchy: Strategic use of whitespace can guide the reader's attention to the most important elements on the page.
Enhance aesthetics: A well-spaced document simply looks more polished and professional.

When spaces are missing or inconsistent, the document can appear cluttered and difficult to read. This is why it's so important to ensure that your PDF generator correctly handles whitespace, especially in complex layouts with nested HTML tags.

Code Example: Setting Up the HTML Handler

Let's take a look at the code snippet provided. Here's how you're configuring the HTML handler in your QuestPDF setup:

col.Item().HTML(handler => ConfigureHtmlHandler(handler, "This is a bold text"));

private void ConfigureHtmlHandler(HTMLDescriptor handler, string htmlContent)
{
    handler.SetTextStyleForHtmlElement("h1", TextStyle.Default.FontSize(16).Bold());
    handler.SetTextStyleForHtmlElement("h2", TextStyle.Default.FontSize(14).Bold());
    handler.SetTextStyleForHtmlElement("h3", TextStyle.Default.Bold());
    handler.SetTextStyleForHtmlElement("h4", TextStyle.Default.Bold());
    handler.SetContainerStyleForHtmlElement("ul", c => c.PaddingVertical(10));
    handler.SetHtml(htmlContent ?? string.Empty);
}

In this code, you're defining styles for various HTML elements like h1, h2, h3, and h4, and also setting a container style for ul elements. The crucial part is the handler.SetHtml(htmlContent ?? string.Empty); line, which sets the HTML content that QuestPDF will render. The ?? string.Empty part is a null-coalescing operator, ensuring that if htmlContent is null, it defaults to an empty string to avoid any null reference exceptions.

Potential Causes and Solutions for Handling Blank Spaces

Now, let's talk about why those spaces might be disappearing and what you can do about it. Here are a few potential causes and solutions to consider:

CSS Styling: CSS can sometimes collapse or ignore whitespace, especially if there are conflicting styles or specific CSS rules that affect spacing. For example, the white-space property in CSS controls how whitespace is handled. By default, it collapses sequences of whitespace into a single space. To preserve whitespace, you can use white-space: pre;, white-space: pre-wrap;, or white-space: pre-line; depending on your specific needs.
HTML Parsing Issues: The HTML parser might be stripping out or collapsing whitespace during the parsing process. This can happen if the parser is not correctly interpreting the   entities or if it's applying default whitespace collapsing rules.
QuestPDF's HTML Renderer: There might be an issue with how QuestPDF's HTML renderer handles whitespace, particularly within nested tags. This could be a bug in the library or a limitation in its HTML parsing capabilities.

Solutions to Preserve Spaces

Use CSS to Control Whitespace: Adding CSS rules to your HTML content can help preserve whitespace. For example, you can use the white-space property to control how whitespace is handled within specific elements. Here's how you can do it:
```
This is a&nbsp;bold&nbsp;text
```
By setting white-space: pre;, you're telling the browser (or in this case, QuestPDF's renderer) to preserve all whitespace, including spaces and line breaks. This can be a simple and effective way to ensure that your spaces are rendered correctly.
Replace   with CSS-Based Spacing: Instead of relying on   entities, you can use CSS properties like margin or padding to create spacing. This can give you more control over the spacing and avoid potential issues with HTML parsing.
```
This is aboldtext
```
In this example, we're using margin-right and margin-left to add a 5-pixel space around the word "bold". You can adjust the margin values to suit your specific needs.
Encode Spaces Directly: Instead of using  , try using the direct Unicode character for a non-breaking space ( ). Sometimes, this can be more reliably interpreted by HTML renderers.
```
This is a&#160;bold&#160;text
```
This ensures that the non-breaking space is explicitly encoded in the HTML, which can help prevent it from being collapsed or ignored.
Check for Conflicting Styles: Review your CSS styles to ensure that there are no rules that might be collapsing or hiding whitespace. Pay attention to properties like white-space, margin, padding, and display, as these can all affect how whitespace is rendered.

For example, if you have a rule that sets display: inline-block; on an element, it might collapse whitespace around that element. Removing or modifying the rule can help preserve the spaces.
Update QuestPDF and HTML Renderer: Make sure you're using the latest versions of QuestPDF and the QuestPDF.HTML package. Bug fixes and improvements are often released that address issues like this.

You mentioned you're using QuestPDF version 2025.7.4 and QuestPDF.HTML version 1.4.2. Check if there are any newer versions available and update if necessary. The latest versions might include fixes for whitespace handling.
Simplify HTML Structure: Sometimes, complex HTML structures with deeply nested tags can cause issues with whitespace rendering. Try simplifying your HTML structure to see if it resolves the problem.

For example, if you have multiple nested span tags, try reducing the number of nested tags or using a different HTML element that might be better suited for your layout.
Custom HTML Processing: As a last resort, you could pre-process the HTML content before passing it to QuestPDF. This could involve replacing   entities with actual spaces or adding CSS styles to preserve whitespace.

You can use a regular expression to find and replace   entities with spaces, or you can use an HTML parsing library to manipulate the HTML structure and add CSS styles programmatically.

QuestPDF Version and .NET Version

You're currently using QuestPDF version 2025.7.4, QuestPDF.HTML version 1.4.2, and .NET version 9.0. It's always a good idea to keep your libraries up to date. Check for newer versions of QuestPDF and QuestPDF.HTML, as updates often include bug fixes and improvements that could address this issue.

Conclusion: Making Spaces Stick

Dealing with disappearing spaces can be frustrating, but with the right approach, you can ensure that your HTML renders correctly in QuestPDF. By using CSS to control whitespace, encoding spaces directly, and keeping your libraries up to date, you can create visually appealing and well-formatted PDFs. Keep experimenting with these solutions until you find the one that works best for your specific HTML structure and styling needs. Happy coding, and may your spaces always be preserved! Keep me updated if you have more questions. If none of these suggestions solves the problem, consider opening a new issue on the QuestPDF GitHub repository. By providing detailed information, including the QuestPDF version, HTML version, .NET version, and a minimal code example, you can help the developers identify and fix the issue more quickly. Good luck!