From 4e107e3ce58452278c3b6b90585e77a160ce45eb Mon Sep 17 00:00:00 2001
From: "Daniel J. Rollins" <daniel@djrollins.com>
Date: Thu, 25 Apr 2024 22:09:41 +0100
Subject: [PATCH 1/2] test(parser): add failing test for greedy raw element
 parser

---
 parser/v2/raw_test.go | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)

diff --git a/parser/v2/raw_test.go b/parser/v2/raw_test.go
index 7888e37c3..26de32849 100644
--- a/parser/v2/raw_test.go
+++ b/parser/v2/raw_test.go
@@ -90,3 +90,36 @@ func TestRawElementParser(t *testing.T) {
 		})
 	}
 }
+
+func TestRawElementParserIsNotGreedy(t *testing.T) {
+	var tests = []struct {
+		name     string
+		input    string
+		expected RawElement
+	}{
+		{
+			name:  "styles tag",
+			input: `<styles></styles>`,
+		},
+		{
+			name:  "scripts tag",
+			input: `<scripts></scripts>`,
+		},
+	}
+	for _, tt := range tests {
+		tt := tt
+		t.Run(tt.name, func(t *testing.T) {
+			input := parse.NewInput(tt.input)
+			actual, ok, err := rawElements.Parse(input)
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if ok {
+				t.Fatalf("unexpected success for input %q", tt.input)
+			}
+			if actual != nil {
+				t.Fatalf("expected nil Node got %v", actual)
+			}
+		})
+	}
+}

From 1bfbec19977b2a52f6aedf115878f11b4e997b04 Mon Sep 17 00:00:00 2001
From: "Daniel J. Rollins" <daniel@djrollins.com>
Date: Thu, 25 Apr 2024 22:10:20 +0100
Subject: [PATCH 2/2] fix(parser): use element name parser to extract name for
 raw parser

In the existing code, if the raw element name is successfully parsed,
it immediately attempts to parse the attributes, without checking
for whitespace or a closing `>`.

This means that something like `<scripts>` would be parsed as a
`<script>` tag with a boolean attribute of `s` (the last character of
the tag name). This would then give a confusing error about mismatched
tags as the closing `</scripts>` tag was actually parsed correctly.

This commit fixes this issue by delegating to the elementNameParser,
which checks for whitespace or a closing `>`, and then compares the
names of the elements.
---
 parser/v2/raw.go | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/parser/v2/raw.go b/parser/v2/raw.go
index 083c2afb6..6cdeed369 100644
--- a/parser/v2/raw.go
+++ b/parser/v2/raw.go
@@ -28,11 +28,17 @@ func (p rawElementParser) Parse(pi *parse.Input) (n Node, ok bool, err error) {
 
 	// Element name.
 	var e RawElement
-	if e.Name, ok, err = parse.String(p.name).Parse(pi); err != nil || !ok {
+	if e.Name, ok, err = elementNameParser.Parse(pi); err != nil || !ok {
 		pi.Seek(start)
 		return
 	}
 
+	if e.Name != p.name {
+		pi.Seek(start)
+		ok = false
+		return
+	}
+
 	if e.Attributes, ok, err = (attributesParser{}).Parse(pi); err != nil || !ok {
 		pi.Seek(start)
 		return