fix: prevent crash when writing to a closed wrap writer

Closing a WrapWriter returns its ANSI parser to a pool and clears the
reference. When nested writer chains tear down out of order, a trailing
style or link reset can be flushed back through a writer that was already
closed, dereferencing a nil parser and crashing the program.

Treat writes after close as a no-op so this teardown ordering is safe
rather than fatal.

Author: taciturnaxolotl

wrap.go

@@ -63,6 +63,12 @@ func (w *WrapWriter) Link() uv.Link {
 
 // Write writes to the buffer.
 func (w *WrapWriter) Write(p []byte) (int, error) {
+	if w.p == nil {
+		// The writer has been closed and its parser returned to the pool.
+		// Writing after close can happen during out-of-order teardown of
+		// nested writer chains; treat it as a no-op rather than panicking.
+		return len(p), nil
+	}
 	for i := range p {
 		b := p[i]
 		w.p.Advance(b)

wrap_test.go

@@ -0,0 +1,28 @@
+package lipgloss
+
+import (
+	"bytes"
+	"testing"
+)
+
+// TestWrapWriterWriteAfterClose verifies that writing to a WrapWriter after it
+// has been closed is a safe no-op rather than a nil-pointer panic. Close()
+// returns the internal ANSI parser to a sync.Pool and nils it out; out-of-order
+// teardown of nested writer chains can route a trailing style/link reset back
+// through an already-closed writer, so Write must tolerate a nil parser.
+func TestWrapWriterWriteAfterClose(t *testing.T) {
+	var buf bytes.Buffer
+	w := NewWrapWriter(&buf)
+
+	if err := w.Close(); err != nil {
+		t.Fatalf("close: %v", err)
+	}
+
+	n, err := w.Write([]byte("after close"))
+	if err != nil {
+		t.Fatalf("write after close: %v", err)
+	}
+	if n != len("after close") {
+		t.Fatalf("write after close: got n=%d, want %d", n, len("after close"))
+	}
+}