[golang/go] proposal: x/net/html: add a ParseOption to control open element stack limit

### ROOT CAUSE The HTML parser in Go has a default limit on the number of open elements it tracks, which is set to 512. This limit was introduced to prevent quadratic parsing complexity and potential performance issues. However, certain legitimate HTML documents may require more than 512 open elements, causing parsing errors. By making this limit configurable via a new `ParseOption`, users can adjust it based on their specific needs, balancing between strictness and flexibility. ### CODE FIX To implement this feature, we need to add a new `ParseOption` that allows users to set the open element stack limit. Here's how to do it: 1. **Add the new ParseOption function**:

// ParseOptionOpenElementLimit configures the open element limit. This limit
// controls the number of nested open HTML elements that the parser is willing
// to track. Parsing a HTML document that exceeds this limit results in a parse
// error. Increasing this limit can result in quadratic parsing complexity in
// relation to the size of the input, so should be used carefully if parsing
// arbitrary HTML.
//
// By default, the limit is 512.
func ParseOptionOpenElementLimit(limit int) ParseOption {
    return func(*parser) {
        if limit < 0 {
            // Handle invalid limit, maybe reset to default
            limit = defaultOpenElementLimit
        }
        // Store the limit in the parser's state
        parser.openElementLimit = limit
    }
}


2. **Modify the HTML parser to use the new option**:

// Inside the parser's New function or initialization
parser.openElementLimit = defaultOpenElementLimit

// Modify the parse logic to check against the openElementLimit


3. **Update the parsing logic**:

// Within the parsing function, adjust the logic to respect the openElementLimit
if len(openElements) >= parser.openElementLimit {
    // Handle parse error or limit
}


4. **Testing**:

func TestParseOptionOpenElementLimit(t *testing.T) {
    // Test default limit
    {
        doc, err := Parse([]byte("
"), nil)
        // Assert no error
    }
    // Test limit exceeded
    {
        doc, err := Parse(GenerateDeepHTML(parser.openElementLimit + 1), ParseOptionOpenElementLimit(parser.openElementLimit +1))
        // Assert no error
    }
    // Test limit set to zero
    {
        doc, err := Parse([]byte("
"), ParseOptionOpenElementLimit(0))
        // Assert error due to invalid limit
    }
}


This implementation allows users to configure the open element stack limit, providing flexibility while maintaining the parser's performance constraints.

                    
                    

                        
Deploy with DigitalOcean
                        
Use this fix in production instantly. Claim your $200 developer credit.
                        Get Started →
                    
                

                
© 2026 DigitalRavenCo • Privacy