output:

```
ok
tag 'a' is not properly closed
```

## Documentation

### Error Handling

Validation function returns a slice of errors (`[]error`) as type of `ValidationErrors`.

You can join all errors as one by using `Join()` function:

##### Stop after first error

It will return after an error occurs

##### Check error types

You can check type of errors:

Example

```go
var err error
for _, e := range validationErrors {
switch v := e.(type) {
case htmlcheck.ErrInvAttribute:
err = errors.Join(err, fmt.Errorf("inv attr: '%s'", v.AttributeName))
case htmlcheck.ErrInvAttributeValue:
err = errors.Join(err, fmt.Errorf("inv attr val: '%s'", v.AttributeValue))
case htmlcheck.ErrInvClosedBeforeOpened:
err = errors.Join(err, fmt.Errorf("closed before opened: '%s'", v.TagName))
case htmlcheck.ErrInvDuplicatedAttribute:
err = errors.Join(err, fmt.Errorf("dup attr: '%s'", v.AttributeName))
case htmlcheck.ErrInvTag:
err = errors.Join(err, fmt.Errorf("inv tag: '%s'", v.TagName))
case htmlcheck.ErrInvNotProperlyClosed:
err = errors.Join(err, fmt.Errorf("not properly closed: '%s'", v.TagName))
case htmlcheck.ErrInvEOF:
err = errors.Join(err, fmt.Errorf("EOF"))
default:
err = errors.Join(err, fmt.Errorf("Validation error: '%s'", e.Error()))
}
}
```

#### Register Callback

```go
v.RegisterCallback(func(tagName string, attributeName string, value string, reason ErrorReason) error {
if reason == InvTag || reason == InvAttribute {
return fmt.Errorf("validation error: tag '%s', attr: %s", tagName, attributeName)
}
return nil
})
```

### Validator Functions

##### AddValidTag

```go
validator := htmlcheck.Validator{}
validator.AddValidTag(ValidTag{
Name: "b",
IsSelfClosing: false,
})
```

##### AddValidTags

```go
validator := htmlcheck.Validator{}
validator.AddValidTags([]*htmlcheck.ValidTag{
{ Name: "div" },
{ Name: "p" },
})
```

##### AddGroup / AddGroups

You can group attributes to use in valid tags by group name

```go
validator := htmlcheck.Validator{}
// consider it should only accept http/https urls in some attributes in this example
httpRegex := &htmlcheck.AttributeValue{Regex: "^(http(s|))://.*"}
validator.AddGroup(&htmlcheck.TagGroup{
Name: "valid-links",
Attrs: []htmlcheck.Attribute{
{Name: "href", Value: httpRegex},
{Name: "src", Value: httpRegex},
},
})
validator.AddValidTag(htmlcheck.ValidTag{ Name: "a", Groups: []string{"valid-links"} })
validator.AddValidTag(htmlcheck.ValidTag{ Name: "img", Groups: []string{"valid-links"} })
```

### Types

#### ValidTag

| Field | Type | Description |
| ---------------- | ------------- | ---------------------------------------------------------------- |
| `Name` | `string` | Name of tag such as `div`, `a`, `p`, `span`, etc. |
| `Attrs` | `[]Attribute` | Valid Attribute list for the tag |
| `AttrRegex` | `string` | Attributes that match the regex are valid |
| `AttrStartsWith` | `string` | Attributes that starts with the given input are valid |
| `Groups` | `[]string` | Group list |
| `IsSelfClosing` | `bool` | If true, tag will be valid without closing tag, default: `false` |

Example

```go
validator.AddValidTags([]*htmlcheck.ValidTag{
{ Name: "div", Attrs: []htmlcheck.Attribute{ {Name: "id"} } },
{ Name: "p", AttrStartsWith: "data-" },
{ Name: "a", AttrRegex: "^(data-).+" },
})
```

#### Attribute

| Field | Type | Description |
| ------- | ----------------- | -------------------------------------------------------- |
| `Name` | `string` | Name of attribute such as `href`, `class`, `style`, etc. |
| `Value` | `*AttributeValue` | Valid values for the attribute |

Example

```go
validLink := htmlcheck.ValidTag{
Name: "a",
Attrs: []htmlcheck.Attribute{
{Name: "id"},
{Name: "href", Value: &htmlcheck.AttributeValue{Regex: "^(http(s|))://.*"}}, // valid regex for href attribute value
{Name: "target", Value: &htmlcheck.AttributeValue{List: []string{"_target", "_blank"}}}, // valid values for target attribute value
},
}
```

#### AttributeValue

| Field | Type | Description |
| ------------ | ---------- | -------------------------------------------------------------- |
| `List` | `[]string` | List of valid attribute values (for example valid class names) |
| `Regex` | `string` | Attribute values that match the regex are valid |
| `StartsWith` | `string` | Attributes that starts with the given input are valid |

Example

```go
validLink := htmlcheck.ValidTag{
Name: "a",
Attrs: []htmlcheck.Attribute{
{Name: "id"},
{Name: "href", Value: &htmlcheck.AttributeValue{Regex: "^(http(s|))://.*"}}, // valid regex for href attribute value
{Name: "target", Value: &htmlcheck.AttributeValue{List: []string{"_target", "_blank"}}}, // valid values for target attribute value
},
}
```

#### TagGroup

| Field | Type | Description |
| ------- | ------------- | ---------------------------------- |
| `Name` | `string` | Name of group |
| `Attrs` | `[]Attribute` | Valid Attribute list for the group |

Example

```go
// consider it should only accept http/https urls in some attributes in this example
httpRegex := &htmlcheck.AttributeValue{Regex: "^(http(s|))://.*"}
validator.AddGroup(&htmlcheck.TagGroup{
Name: "valid-links",
Attrs: []htmlcheck.Attribute{
{Name: "href", Value: httpRegex},
{Name: "src", Value: httpRegex},
},
})
```

### Error Types

| Type | Description |
| --------------------------- | ------------------------------------------------------------------------------------- |
| `ErrInvTag` | Tag is not valid |
| `ErrInvClosedBeforeOpened` | Tag closed before opened e.g: `